From c326ba8c63dc36f16e99524e4489b76891b41c96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Delabrouille?= <34384633+tdelabro@users.noreply.github.com> Date: Wed, 8 Mar 2023 16:38:18 +0100 Subject: [PATCH 01/15] Wasm32 support (#828) * feat: introduce no_std support * refact: move func from Runner to VM --- .github/workflows/rust.yml | 8 + Cargo.lock | 325 ++-- Cargo.toml | 102 +- Makefile | 22 +- bench/criterion_benchmark.rs | 3 +- bench/iai_benchmark.rs | 10 +- bench/run_benchmarks.sh | 2 +- cairo-vm-cli/Cargo.toml | 11 + {src => cairo-vm-cli/src}/main.rs | 90 +- deps/parse-hyperlinks/Cargo.toml | 10 +- deps/parse-hyperlinks/src/lib.rs | 5 + felt/Cargo.toml | 19 +- felt/src/bigint_felt.rs | 35 +- felt/src/lib.rs | 56 +- src/cairo_run.rs | 240 ++- .../builtin_hint_processor/blake2s_hash.rs | 12 +- .../builtin_hint_processor/blake2s_utils.rs | 19 +- .../builtin_hint_processor_definition.rs | 28 +- .../cairo_keccak/keccak_hints.rs | 16 +- .../builtin_hint_processor/dict_hint_utils.rs | 36 +- .../builtin_hint_processor/dict_manager.rs | 16 +- .../find_element_hint.rs | 35 +- .../builtin_hint_processor/hint_utils.rs | 17 +- .../builtin_hint_processor/keccak_utils.rs | 3 +- .../builtin_hint_processor/math_utils.rs | 85 +- .../memcpy_hint_utils.rs | 8 +- .../builtin_hint_processor/memset_utils.rs | 13 +- .../builtin_hint_processor/pow_utils.rs | 12 +- .../secp/bigint_utils.rs | 12 +- .../builtin_hint_processor/secp/ec_utils.rs | 22 +- .../secp/field_utils.rs | 21 +- .../builtin_hint_processor/secp/secp_utils.rs | 12 +- .../builtin_hint_processor/secp/signature.rs | 20 +- .../builtin_hint_processor/segments.rs | 9 +- .../builtin_hint_processor/set.rs | 12 +- .../builtin_hint_processor/sha256_utils.rs | 9 +- .../builtin_hint_processor/signature.rs | 8 +- .../squash_dict_utils.rs | 70 +- .../builtin_hint_processor/uint256_utils.rs | 26 +- .../builtin_hint_processor/usort.rs | 10 +- .../hint_processor_definition.rs | 4 +- src/hint_processor/hint_processor_utils.rs | 20 +- src/lib.rs | 49 + src/math_utils.rs | 27 +- src/serde/deserialize_program.rs | 99 +- src/serde/deserialize_utils.rs | 33 +- {tests => src/tests}/bitwise_test.rs | 18 +- src/tests/cairo_run_test.rs | 1402 +++++++++++++++++ {tests => src/tests}/compare_vm_state.sh | 0 {tests => src/tests}/memory_comparator.py | 0 src/tests/mod.rs | 7 + {tests => src/tests}/pedersen_test.rs | 20 +- {tests => src/tests}/skip_instruction_test.rs | 21 +- {tests => src/tests}/struct_test.rs | 24 +- src/types/errors/math_errors.rs | 4 + src/types/errors/program_errors.rs | 16 +- src/types/exec_scope.rs | 18 +- .../bitwise_instance_def.rs | 7 + .../builtins_instance_def.rs | 10 + .../instance_definitions/cpu_instance_def.rs | 4 + .../diluted_pool_instance_def.rs | 5 + .../ec_op_instance_def.rs | 7 + .../ecdsa_instance_def.rs | 7 + .../keccak_instance_def.rs | 9 + .../pedersen_instance_def.rs | 7 + .../range_check_instance_def.rs | 7 + src/types/instruction.rs | 6 + src/types/layout.rs | 12 + src/types/program.rs | 60 +- src/types/relocatable.rs | 53 +- src/utils.rs | 81 +- src/vm/context/run_context.rs | 15 + src/vm/decoding/decoder.rs | 16 + src/vm/errors/cairo_run_errors.rs | 6 +- src/vm/errors/exec_scope_errors.rs | 3 + src/vm/errors/hint_errors.rs | 8 +- src/vm/errors/memory_errors.rs | 8 +- src/vm/errors/runner_errors.rs | 10 +- src/vm/errors/trace_errors.rs | 6 +- src/vm/errors/vm_errors.rs | 13 +- src/vm/errors/vm_exception.rs | 179 ++- src/vm/hooks.rs | 25 +- src/vm/runners/builtin_runner/bitwise.rs | 31 +- src/vm/runners/builtin_runner/ec_op.rs | 118 +- src/vm/runners/builtin_runner/hash.rs | 25 +- src/vm/runners/builtin_runner/keccak.rs | 39 +- src/vm/runners/builtin_runner/mod.rs | 79 + src/vm/runners/builtin_runner/output.rs | 26 +- src/vm/runners/builtin_runner/range_check.rs | 38 +- src/vm/runners/builtin_runner/signature.rs | 32 +- src/vm/runners/cairo_runner.rs | 269 ++-- src/vm/security.rs | 15 +- src/vm/trace/mod.rs | 8 +- src/vm/trace/trace_entry.rs | 8 + src/vm/vm_core.rs | 172 +- src/vm/vm_memory/memory.rs | 69 +- src/vm/vm_memory/memory_segments.rs | 53 +- src/with_alloc.rs | 15 + src/with_std.rs | 34 + src/without_std.rs | 24 + tests/cairo_run_test.rs | 267 ++-- 101 files changed, 4219 insertions(+), 898 deletions(-) create mode 100644 cairo-vm-cli/Cargo.toml rename {src => cairo-vm-cli/src}/main.rs (54%) rename {tests => src/tests}/bitwise_test.rs (94%) create mode 100644 src/tests/cairo_run_test.rs rename {tests => src/tests}/compare_vm_state.sh (100%) rename {tests => src/tests}/memory_comparator.py (100%) create mode 100644 src/tests/mod.rs rename {tests => src/tests}/pedersen_test.rs (87%) rename {tests => src/tests}/skip_instruction_test.rs (61%) rename {tests => src/tests}/struct_test.rs (63%) create mode 100644 src/with_alloc.rs create mode 100644 src/with_std.rs create mode 100644 src/without_std.rs diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 48e96fe5c8..49d668e8c2 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -28,6 +28,10 @@ jobs: uses: taiki-e/install-action@nextest - name: Install cargo-llvm-cov uses: taiki-e/install-action@cargo-llvm-cov + - name: Install wasm-bindgen-cli + uses: jetli/wasm-pack-action@v0.4.0 + with: + version: "v0.10.3" - name: Set up cargo cache uses: Swatinem/rust-cache@v2 @@ -62,6 +66,10 @@ jobs: run: pip install ecdsa fastecdsa sympy cairo-lang - name: Run tests run: make -j test + - name: Run tests no_std + run: make -j test-no_std + - name: Run wasm tests + run: make -j test-wasm - name: Compare trace and memory run: make -j compare_trace_memory - name: Compare trace and memory with proof mode diff --git a/Cargo.lock b/Cargo.lock index dabc670b47..a28f8f71cc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,23 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "ahash" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f" +dependencies = [ + "cfg-if", + "once_cell", + "version_check", +] + +[[package]] +name = "anyhow" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800" + [[package]] name = "ark-ff" version = "0.3.0" @@ -86,23 +103,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" [[package]] -name = "bigdecimal" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6aaf33151a6429fe9211d1b276eafdf70cdff28b071e76c0b0e1503221ea3744" +name = "bincode" +version = "2.0.0-rc.2" +source = "git+https://github.com/bincode-org/bincode.git?tag=v2.0.0-rc.2#6c219e9214bda2bdce1327db6ed7f66d2fa4bf02" dependencies = [ - "num-bigint", - "num-integer", - "num-traits", + "bincode_derive", + "serde", ] [[package]] -name = "bincode" -version = "1.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" +name = "bincode_derive" +version = "2.0.0-rc.2" +source = "git+https://github.com/bincode-org/bincode.git?tag=v2.0.0-rc.2#6c219e9214bda2bdce1327db6ed7f66d2fa4bf02" dependencies = [ - "serde", + "virtue", ] [[package]] @@ -126,15 +140,6 @@ version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" -[[package]] -name = "block-buffer" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4" -dependencies = [ - "generic-array", -] - [[package]] name = "block-buffer" version = "0.10.3" @@ -144,18 +149,6 @@ dependencies = [ "generic-array", ] -[[package]] -name = "bstr" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" -dependencies = [ - "lazy_static", - "memchr", - "regex-automata", - "serde", -] - [[package]] name = "bumpalo" version = "3.12.0" @@ -170,7 +163,7 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" [[package]] name = "cairo-felt" -version = "0.1.3" +version = "0.2.0" dependencies = [ "lazy_static", "num-bigint", @@ -182,14 +175,15 @@ dependencies = [ [[package]] name = "cairo-vm" -version = "0.1.3" +version = "0.2.0" dependencies = [ + "anyhow", "assert_matches", "bincode", "cairo-felt", - "clap 3.2.23", "criterion", "generic-array", + "hashbrown 0.13.2", "hex", "iai", "keccak", @@ -205,10 +199,23 @@ dependencies = [ "serde", "serde_bytes", "serde_json", - "sha2 0.10.6", + "sha2", "sha3", "starknet-crypto", "thiserror", + "thiserror-no-std", + "wasm-bindgen-test", +] + +[[package]] +name = "cairo-vm-cli" +version = "0.1.0" +dependencies = [ + "bincode", + "cairo-vm", + "clap 3.2.23", + "nom", + "thiserror", ] [[package]] @@ -288,6 +295,16 @@ dependencies = [ "os_str_bytes", ] +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + [[package]] name = "cpufeatures" version = "0.2.5" @@ -378,12 +395,11 @@ dependencies = [ [[package]] name = "crypto-bigint" -version = "0.3.2" +version = "0.4.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03c6a1d5fa1de37e071642dfa44ec552ca5b299adb128fab16138e24b548fd21" +checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef" dependencies = [ "generic-array", - "rand_core", "subtle", "zeroize", ] @@ -398,25 +414,14 @@ dependencies = [ "typenum", ] -[[package]] -name = "crypto-mac" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714" -dependencies = [ - "generic-array", - "subtle", -] - [[package]] name = "csv" -version = "1.1.6" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1" +checksum = "af91f40b7355f82b0a891f50e70399475945bb0b0da4f1700ce60761c9d3e359" dependencies = [ - "bstr", "csv-core", - "itoa 0.4.8", + "itoa", "ryu", "serde", ] @@ -456,15 +461,16 @@ version = "0.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f" dependencies = [ - "block-buffer 0.10.3", + "block-buffer", "crypto-common", + "subtle", ] [[package]] name = "either" -version = "1.8.0" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797" +checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91" [[package]] name = "envmnt" @@ -541,11 +547,21 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +[[package]] +name = "hashbrown" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" +dependencies = [ + "ahash", + "serde", +] + [[package]] name = "heck" -version = "0.4.0" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" [[package]] name = "hermit-abi" @@ -573,12 +589,11 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" [[package]] name = "hmac" -version = "0.11.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" dependencies = [ - "crypto-mac", - "digest 0.9.0", + "digest 0.10.6", ] [[package]] @@ -594,7 +609,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399" dependencies = [ "autocfg", - "hashbrown", + "hashbrown 0.12.3", ] [[package]] @@ -615,12 +630,6 @@ dependencies = [ "either", ] -[[package]] -name = "itoa" -version = "0.4.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" - [[package]] name = "itoa" version = "1.0.5" @@ -629,9 +638,9 @@ checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440" [[package]] name = "js-sys" -version = "0.3.60" +version = "0.3.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47" +checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730" dependencies = [ "wasm-bindgen", ] @@ -650,6 +659,9 @@ name = "lazy_static" version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" +dependencies = [ + "spin", +] [[package]] name = "libc" @@ -657,6 +669,12 @@ version = "0.2.139" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79" +[[package]] +name = "libm" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb" + [[package]] name = "libmimalloc-sys" version = "0.1.30" @@ -751,6 +769,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" dependencies = [ "autocfg", + "libm", ] [[package]] @@ -775,12 +794,6 @@ version = "11.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" -[[package]] -name = "opaque-debug" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" - [[package]] name = "os_str_bytes" version = "6.4.1" @@ -792,6 +805,7 @@ name = "parse-hyperlinks" version = "0.23.4" dependencies = [ "nom", + "wasm-bindgen-test", ] [[package]] @@ -879,9 +893,9 @@ dependencies = [ [[package]] name = "proptest" -version = "1.0.0" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e0d9cc07f18492d879586c92b485def06bc850da3118075cd45d50e9c95b0e5" +checksum = "29f1b898011ce9595050a68e60f90bad083ff2987a695a42357134c8381fba70" dependencies = [ "bit-set", "bitflags", @@ -895,6 +909,7 @@ dependencies = [ "regex-syntax", "rusty-fork", "tempfile", + "unarray", ] [[package]] @@ -997,12 +1012,6 @@ dependencies = [ "regex-syntax", ] -[[package]] -name = "regex-automata" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" - [[package]] name = "regex-syntax" version = "0.6.28" @@ -1020,9 +1029,9 @@ dependencies = [ [[package]] name = "rfc6979" -version = "0.1.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96ef608575f6392792f9ecf7890c00086591d29a83910939d430753f7c050525" +checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb" dependencies = [ "crypto-bigint", "hmac", @@ -1077,6 +1086,12 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + [[package]] name = "scopeguard" version = "1.1.0" @@ -1112,9 +1127,9 @@ dependencies = [ [[package]] name = "serde_bytes" -version = "0.11.8" +version = "0.11.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "718dc5fff5b36f99093fc49b280cfc96ce6fc824317783bff5a1fed0c7a64819" +checksum = "416bda436f9aab92e02c8e10d49a15ddd339cea90b6e340fe51ed97abb548294" dependencies = [ "serde", ] @@ -1146,24 +1161,11 @@ version = "1.0.91" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883" dependencies = [ - "itoa 1.0.5", + "itoa", "ryu", "serde", ] -[[package]] -name = "sha2" -version = "0.9.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" -dependencies = [ - "block-buffer 0.9.0", - "cfg-if", - "cpufeatures", - "digest 0.9.0", - "opaque-debug", -] - [[package]] name = "sha2" version = "0.10.6" @@ -1185,32 +1187,37 @@ dependencies = [ "keccak", ] +[[package]] +name = "spin" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" + [[package]] name = "starknet-crypto" version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be7d6b2c959fde2a10dbc31d54bdd0307eecb7ef6c05c23a0263e65b57b3e18a" +source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" dependencies = [ "crypto-bigint", + "hashbrown 0.13.2", "hex", "hmac", "num-bigint", "num-integer", "num-traits", "rfc6979", - "sha2 0.9.9", + "sha2", "starknet-crypto-codegen", "starknet-curve", "starknet-ff", - "thiserror", + "thiserror-no-std", "zeroize", ] [[package]] name = "starknet-crypto-codegen" version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6569d70430f0f6edc41f6820d00acf63356e6308046ca01e57eeac22ad258c47" +source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" dependencies = [ "starknet-curve", "starknet-ff", @@ -1220,8 +1227,7 @@ dependencies = [ [[package]] name = "starknet-curve" version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84be6079d3060fdbd8b5335574fef3d3783fa2f7ee6474d08ae0c1e4b0a29ba4" +source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" dependencies = [ "starknet-ff", ] @@ -1229,17 +1235,14 @@ dependencies = [ [[package]] name = "starknet-ff" version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5874510620214ebeac50915b01d67437d8ca10a6682b1de85b93cd01157b58eb" +source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" dependencies = [ "ark-ff", - "bigdecimal", "crypto-bigint", "getrandom", "hex", - "num-bigint", "serde", - "thiserror", + "thiserror-no-std", ] [[package]] @@ -1335,6 +1338,26 @@ dependencies = [ "syn", ] +[[package]] +name = "thiserror-impl-no-std" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58e6318948b519ba6dc2b442a6d0b904ebfb8d411a3ad3e07843615a72249758" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror-no-std" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3ad459d94dd517257cc96add8a43190ee620011bb6e6cdc82dafd97dfafafea" +dependencies = [ + "thiserror-impl-no-std", +] + [[package]] name = "tinytemplate" version = "1.2.1" @@ -1366,6 +1389,12 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81" +[[package]] +name = "unarray" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" + [[package]] name = "unicode-ident" version = "1.0.6" @@ -1390,6 +1419,12 @@ version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" +[[package]] +name = "virtue" +version = "0.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b60dcd6a64dd45abf9bd426970c9843726da7fc08f44cd6fcebf68c21220a63" + [[package]] name = "wait-timeout" version = "0.2.0" @@ -1418,9 +1453,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] name = "wasm-bindgen" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268" +checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b" dependencies = [ "cfg-if", "wasm-bindgen-macro", @@ -1428,9 +1463,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-backend" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142" +checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9" dependencies = [ "bumpalo", "log", @@ -1441,11 +1476,23 @@ dependencies = [ "wasm-bindgen-shared", ] +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + [[package]] name = "wasm-bindgen-macro" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810" +checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -1453,9 +1500,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c" +checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6" dependencies = [ "proc-macro2", "quote", @@ -1466,9 +1513,33 @@ dependencies = [ [[package]] name = "wasm-bindgen-shared" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f" +checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d" + +[[package]] +name = "wasm-bindgen-test" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db36fc0f9fb209e88fb3642590ae0205bb5a56216dabd963ba15879fe53a30b" +dependencies = [ + "console_error_panic_hook", + "js-sys", + "scoped-tls", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-bindgen-test-macro", +] + +[[package]] +name = "wasm-bindgen-test-macro" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0734759ae6b3b1717d661fe4f016efcfb9828f5edb4520c18eaee05af3b43be9" +dependencies = [ + "proc-macro2", + "quote", +] [[package]] name = "web-sys" diff --git a/Cargo.toml b/Cargo.toml index 29b7f9e967..7794e20ad5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,62 +1,88 @@ [workspace] -members = [".", "felt", "./deps/parse-hyperlinks"] +members = [".", "felt", "cairo-vm-cli", "./deps/parse-hyperlinks"] [package] name = "cairo-vm" -version = "0.1.3" +version = "0.2.0" edition = "2021" license = "Apache-2.0" description = "Blazing fast Cairo interpreter" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [features] -default = ["with_mimalloc"] +default = ["std", "with_mimalloc"] with_mimalloc = ["mimalloc"] -# This feature will reference every test-oriented feature. +std = [ + "serde_json/std", + "serde_bytes/std", + "bincode/std", + "anyhow/std", + "starknet-crypto/std", + "parse-hyperlinks/std", + "felt/std", +] +alloc = [ + "serde_json/alloc", + "serde_bytes/alloc", + "starknet-crypto/alloc", + "parse-hyperlinks/alloc", + "felt/alloc", +] + + # Note that these features are not retro-compatible with the cairo Python VM. -test_utils = ["skip_next_instruction_hint", "hooks"] +test_utils = [ + "skip_next_instruction_hint", + "hooks", +] # This feature will reference every test-oriented feature skip_next_instruction_hint = [] hooks = [] [dependencies] mimalloc = { version = "0.1.29", default-features = false, optional = true } -num-bigint = { version = "0.4", features = ["serde"] } -num-traits = "0.2" -num-integer = "0.1.45" -serde = { version = "1.0", features = ["derive"] } -serde_bytes = "0.11.1" -serde_json = { version = "1.0", features = ["arbitrary_precision"] } -hex = "0.4.3" -bincode = "1.2.1" -starknet-crypto = "0.2.0" -clap = { version = "3.2.5", features = ["derive"] } -sha3 = "0.10.1" -rand_core = "0.6.4" -lazy_static = "1.4.0" -nom = "7" -sha2 = { version = "0.10.2", features = ["compress"] } -thiserror = "1.0.32" -generic-array = "0.14.6" -keccak = "0.1.2" +num-bigint = { version = "0.4", features = ["serde"], default-features = false } +num-traits = { version = "0.2", default-features = false } +num-integer = { version = "0.1.45", default-features = false } +serde = { version = "1.0", features = ["derive"], default-features = false } +serde_bytes = { version = "0.11.9", default-features = false } +serde_json = { version = "1.0", features = [ + "arbitrary_precision", +], default-features = false } +hex = { version = "0.4.3", default-features = false } +bincode = { tag = "v2.0.0-rc.2", git = "https://github.com/bincode-org/bincode.git", default-features = false, features = [ + "serde", +] } +starknet-crypto = { git = "https://github.com/tdelabro/starknet-rs.git", branch = "feature/manual-no-std-bigdecimal", default-features = false } +sha3 = { version = "0.10.1", default-features = false } +rand_core = { version = "0.6.4", default-features = false } +lazy_static = { version = "1.4.0", default-features = false, features = [ + "spin_no_std", +] } +nom = { version = "7", default-features = false } +sha2 = { version = "0.10.2", features = ["compress"], default-features = false } +generic-array = { version = "0.14.6", default-features = false } +keccak = { version = "0.1.2", default-features = false } +hashbrown = { version = "0.13.2", features = ["serde"] } +anyhow = { version = "1.0.69", default-features = false } +thiserror = { version = "1.0.32", default-features = false } +thiserror-no-std = "2.0.2" + # This crate has only one function `take_until_unbalanced` that is # very useful for our parsing purposes: # https://stackoverflow.com/questions/70630556/parse-allowing-nested-parentheses-in-nom # There is a proposal for extending nom::delimited to use this function: # https://github.com/Geal/nom/issues/1253 -parse-hyperlinks = { path = "./deps/parse-hyperlinks", version = "0.23.4" } -felt = { package = "cairo-felt", path = "./felt", version = "0.1.0" } +parse-hyperlinks = { path = "./deps/parse-hyperlinks", version = "0.23.4", default-features = false } +felt = { package = "cairo-felt", path = "./felt", default-features = false } -[dev-dependencies] -iai = "0.1" +[target.'cfg(target_arch = "wasm32")'.dev-dependencies] +wasm-bindgen-test = "0.3.34" assert_matches = "1.5.0" -[dev-dependencies.rusty-hook] -version = "0.11" - -[dev-dependencies.criterion] -version = "0.3" -features = ["html_reports"] +[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies] +iai = "0.1" +rusty-hook = "0.11" +assert_matches = "1.5.0" +criterion = { version = "0.3", features = ["html_reports"] } [[bench]] path = "bench/iai_benchmark.rs" @@ -68,11 +94,5 @@ path = "bench/criterion_benchmark.rs" name = "criterion_benchmark" harness = false -[[bin]] -name = "cairo-rs-run" -path = "src/main.rs" -bench = false -doc = false - [profile.release] lto = "fat" diff --git a/Makefile b/Makefile index f87c6cb330..5173f74552 100644 --- a/Makefile +++ b/Makefile @@ -32,7 +32,7 @@ $(TEST_PROOF_DIR)/%.json: $(TEST_PROOF_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_PROOF_DIR):$(PROOF_BENCH_DIR)" $< --output $@ --proof_mode $(TEST_PROOF_DIR)/%.rs.trace $(TEST_PROOF_DIR)/%.rs.memory: $(TEST_PROOF_DIR)/%.json $(RELBIN) - cargo llvm-cov run --release --no-report -- --layout all --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory + cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_PROOF_DIR)/%.trace $(TEST_PROOF_DIR)/%.memory: $(TEST_PROOF_DIR)/%.json cairo-run --layout all --proof_mode --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory @@ -68,7 +68,7 @@ $(TEST_DIR)/%.json: $(TEST_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_DIR):$(BENCH_DIR)" $< --output $@ $(TEST_DIR)/%.rs.trace $(TEST_DIR)/%.rs.memory: $(TEST_DIR)/%.json $(RELBIN) - cargo llvm-cov run --release --no-report -- --layout all $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory + cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_DIR)/%.trace $(TEST_DIR)/%.memory: $(TEST_DIR)/%.json cairo-run --layout all --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory @@ -107,7 +107,7 @@ $(RELBIN): build: $(RELBIN) run: - cargo run + cargo run -p cairo-vm-cli check: cargo check @@ -121,6 +121,10 @@ cairo-rs_trace: $(CAIRO_RS_TRACE) $(CAIRO_RS_MEM) test: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) cargo llvm-cov nextest --no-report --workspace --features test_utils +test-no_std: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) + cargo llvm-cov nextest --no-report --workspace --features test_utils --no-default-features --features alloc +test-wasm: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) + wasm-pack test --node --no-default-features --features alloc clippy: cargo clippy --tests --examples --all-features -- -D warnings @@ -148,22 +152,22 @@ compare_benchmarks: $(COMPILED_BENCHES) cd bench && ./run_benchmarks.sh compare_trace_memory: $(CAIRO_RS_TRACE) $(CAIRO_TRACE) $(CAIRO_RS_MEM) $(CAIRO_MEM) - cd tests; ./compare_vm_state.sh trace memory + cd src/tests; ./compare_vm_state.sh trace memory compare_trace: $(CAIRO_RS_TRACE) $(CAIRO_TRACE) - cd tests; ./compare_vm_state.sh trace + cd src/tests; ./compare_vm_state.sh trace compare_memory: $(CAIRO_RS_MEM) $(CAIRO_MEM) - cd tests; ./compare_vm_state.sh memory + cd src/tests; ./compare_vm_state.sh memory compare_trace_memory_proof: $(COMPILED_PROOF_TESTS) $(CAIRO_RS_TRACE_PROOF) $(CAIRO_TRACE_PROOF) $(CAIRO_RS_MEM_PROOF) $(CAIRO_MEM_PROOF) - cd tests; ./compare_vm_state.sh trace memory proof_mode + cd src/tests; ./compare_vm_state.sh trace memory proof_mode compare_trace_proof: $(CAIRO_RS_TRACE_PROOF) $(CAIRO_TRACE_PROOF) - cd tests; ./compare_vm_state.sh trace proof_mode + cd src/tests; ./compare_vm_state.sh trace proof_mode compare_memory_proof: $(CAIRO_RS_MEM_PROOF) $(CAIRO_MEM_PROOF) - cd tests; ./compare_vm_state.sh memory proof_mode + cd src/tests; ./compare_vm_state.sh memory proof_mode # Run with nightly enable the `doc_cfg` feature wich let us provide clear explaination about which parts of the code are behind a feature flag docs: diff --git a/bench/criterion_benchmark.rs b/bench/criterion_benchmark.rs index 4df2f75bc1..2ca326bbce 100644 --- a/bench/criterion_benchmark.rs +++ b/bench/criterion_benchmark.rs @@ -32,10 +32,11 @@ pub fn criterion_benchmarks(c: &mut Criterion) { ..cairo_vm::cairo_run::CairoRunConfig::default() }; for benchmark_name in build_bench_strings() { + let file_content = std::fs::read(Path::new(&benchmark_name.1)).unwrap(); c.bench_function(&benchmark_name.0, |b| { b.iter(|| { cairo_run::cairo_run( - black_box(Path::new(&benchmark_name.1)), + black_box(&file_content), &cairo_run_config, &mut hint_executor, ) diff --git a/bench/iai_benchmark.rs b/bench/iai_benchmark.rs index 9763e99983..496118035e 100644 --- a/bench/iai_benchmark.rs +++ b/bench/iai_benchmark.rs @@ -4,12 +4,13 @@ use cairo_vm::{ cairo_run::cairo_run, hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, vm::errors::cairo_run_errors::CairoRunError, vm::runners::cairo_runner::CairoRunner, + vm::vm_core::VirtualMachine, }; use iai::{black_box, main}; macro_rules! iai_bench_expand_prog { ($val: ident) => { - fn $val() -> Result { + fn $val() -> Result<(CairoRunner, VirtualMachine), CairoRunError> { let cairo_run_config = cairo_vm::cairo_run::CairoRunConfig { layout: "all", ..cairo_vm::cairo_run::CairoRunConfig::default() @@ -20,7 +21,12 @@ macro_rules! iai_bench_expand_prog { stringify!($val), ".json" )); - cairo_run(black_box(path), &cairo_run_config, &mut hint_executor) + let program_content = std::fs::read(path).unwrap(); + cairo_run( + black_box(&program_content), + &cairo_run_config, + &mut hint_executor, + ) } }; } diff --git a/bench/run_benchmarks.sh b/bench/run_benchmarks.sh index 624b2e01d0..e5506de4c9 100755 --- a/bench/run_benchmarks.sh +++ b/bench/run_benchmarks.sh @@ -1,5 +1,5 @@ #!/usr/bin/env sh -tests_path="../cairo_programs/benchmarks" +tests_path="cairo_programs/benchmarks" set -e diff --git a/cairo-vm-cli/Cargo.toml b/cairo-vm-cli/Cargo.toml new file mode 100644 index 0000000000..ee0a5fcc1d --- /dev/null +++ b/cairo-vm-cli/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "cairo-vm-cli" +version = "0.1.0" +edition = "2021" + +[dependencies] +cairo-vm = { path = ".." } +clap = { version = "3.2.5", features = ["derive"] } +nom = "7" +thiserror = { version = "1.0.32" } +bincode = { tag = "v2.0.0-rc.2", git = "https://github.com/bincode-org/bincode.git" } diff --git a/src/main.rs b/cairo-vm-cli/src/main.rs similarity index 54% rename from src/main.rs rename to cairo-vm-cli/src/main.rs index 363dc933aa..f9b05f96db 100644 --- a/src/main.rs +++ b/cairo-vm-cli/src/main.rs @@ -1,11 +1,14 @@ #![deny(warnings)] -use cairo_vm::cairo_run; +use bincode::enc::write::Writer; +use cairo_vm::cairo_run::{self, EncodeTraceError}; use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use cairo_vm::vm::errors::cairo_run_errors::CairoRunError; -use cairo_vm::vm::errors::runner_errors::RunnerError; use cairo_vm::vm::errors::trace_errors::TraceError; +use cairo_vm::vm::errors::vm_errors::VirtualMachineError; use clap::{Parser, ValueHint}; +use std::io::{self, Write}; use std::path::PathBuf; +use thiserror::Error; #[cfg(feature = "with_mimalloc")] use mimalloc::MiMalloc; @@ -43,43 +46,98 @@ fn validate_layout(value: &str) -> Result<(), String> { } } -fn main() -> Result<(), CairoRunError> { +#[derive(Debug, Error)] +enum Error { + #[error("Failed to interact with the file system")] + IO(#[from] std::io::Error), + #[error("The cairo program execution failed")] + Runner(#[from] CairoRunError), + #[error(transparent)] + EncodeTrace(#[from] EncodeTraceError), + #[error(transparent)] + VirtualMachine(#[from] VirtualMachineError), +} + +struct FileWriter { + buf_writer: io::BufWriter, + bytes_written: usize, +} + +impl Writer for FileWriter { + fn write(&mut self, bytes: &[u8]) -> Result<(), bincode::error::EncodeError> { + self.buf_writer + .write_all(bytes) + .map_err(|e| bincode::error::EncodeError::Io { + inner: e, + index: self.bytes_written, + })?; + + self.bytes_written += bytes.len(); + + Ok(()) + } +} + +impl FileWriter { + fn new(buf_writer: io::BufWriter) -> Self { + Self { + buf_writer, + bytes_written: 0, + } + } + + fn flush(&mut self) -> io::Result<()> { + self.buf_writer.flush() + } +} + +fn main() -> Result<(), Error> { let args = Args::parse(); let trace_enabled = args.trace_file.is_some(); let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { entrypoint: &args.entrypoint, trace_enabled, - print_output: args.print_output, layout: &args.layout, proof_mode: args.proof_mode, secure_run: args.secure_run, }; - let cairo_runner = - match cairo_run::cairo_run(&args.filename, &cairo_run_config, &mut hint_executor) { + + let program_content = std::fs::read(args.filename).map_err(|e| Error::IO(e))?; + + let (cairo_runner, mut vm) = + match cairo_run::cairo_run(&program_content, &cairo_run_config, &mut hint_executor) { Ok(runner) => runner, Err(error) => { println!("{error}"); - return Err(error); + return Err(Error::Runner(error)); } }; + if args.print_output { + let mut output_buffer = "Program Output:\n".to_string(); + vm.write_output(&mut output_buffer)?; + print!("{output_buffer}"); + } + if let Some(trace_path) = args.trace_file { let relocated_trace = cairo_runner .relocated_trace - .as_ref() .ok_or(CairoRunError::Trace(TraceError::TraceNotEnabled))?; - match cairo_run::write_binary_trace(relocated_trace, &trace_path) { - Ok(()) => (), - Err(_e) => return Err(CairoRunError::Runner(RunnerError::WriteFail)), - } + + let trace_file = std::fs::File::create(trace_path)?; + let mut trace_writer = FileWriter::new(io::BufWriter::new(trace_file)); + + cairo_run::write_encoded_trace(&relocated_trace, &mut trace_writer)?; + trace_writer.flush()?; } if let Some(memory_path) = args.memory_file { - match cairo_run::write_binary_memory(&cairo_runner.relocated_memory, &memory_path) { - Ok(()) => (), - Err(_e) => return Err(CairoRunError::Runner(RunnerError::WriteFail)), - } + let memory_file = std::fs::File::create(memory_path)?; + let mut memory_writer = FileWriter::new(io::BufWriter::new(memory_file)); + + cairo_run::write_encoded_memory(&cairo_runner.relocated_memory, &mut memory_writer)?; + memory_writer.flush()?; } Ok(()) diff --git a/deps/parse-hyperlinks/Cargo.toml b/deps/parse-hyperlinks/Cargo.toml index b80392e2c7..9752d93471 100644 --- a/deps/parse-hyperlinks/Cargo.toml +++ b/deps/parse-hyperlinks/Cargo.toml @@ -12,4 +12,12 @@ description = "A Nom parser library for hyperlinks with markup." categories = ["command-line-utilities", "parser-implementations"] [dependencies] -nom= "7.1.1" +nom = { version = "7.1.1", default-features = false } + +[features] +default = ["std"] +std = ["nom/std"] +alloc = ["nom/alloc"] + +[target.'cfg(target_arch = "wasm32")'.dev-dependencies] +wasm-bindgen-test = "0.3.34" diff --git a/deps/parse-hyperlinks/src/lib.rs b/deps/parse-hyperlinks/src/lib.rs index cc1aa7af4c..8da099d0c5 100644 --- a/deps/parse-hyperlinks/src/lib.rs +++ b/deps/parse-hyperlinks/src/lib.rs @@ -1,4 +1,5 @@ #![allow(dead_code)] +#![cfg_attr(not(feature = "std"), no_std)] use nom::error::Error; use nom::error::ErrorKind; @@ -87,7 +88,11 @@ mod tests { use super::*; use nom::error::ErrorKind; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_take_until_unmatched() { assert_eq!(take_until_unbalanced('(', ')')("abc"), Ok(("", "abc"))); assert_eq!( diff --git a/felt/Cargo.toml b/felt/Cargo.toml index c21a8706fe..e1a7c221ac 100644 --- a/felt/Cargo.toml +++ b/felt/Cargo.toml @@ -1,18 +1,23 @@ [package] name = "cairo-felt" -version = "0.1.3" +version = "0.2.0" edition = "2021" license = "Apache-2.0" description = "Field elements representation for the Cairo VM" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[features] +default = ["std"] +std = [] +alloc = [] [dependencies] -num-integer = "0.1.45" -num-bigint = { version = "0.4", features = ["serde"] } -num-traits = "0.2.15" -lazy_static = "1.4.0" -serde = { version = "1.0", features = ["derive"] } +num-integer = { version = "0.1.45", default-features = false } +num-bigint = { version = "0.4", features = ["serde"], default-features = false } +num-traits = { version = "0.2.15", default-features = false } +lazy_static = { version = "1.4.0", default-features = false, features = [ + "spin_no_std", +] } +serde = { version = "1.0", features = ["derive"], default-features = false } [dev-dependencies] proptest = "1.0.0" diff --git a/felt/src/bigint_felt.rs b/felt/src/bigint_felt.rs index 8c2a9f8e4a..e0e24acd64 100644 --- a/felt/src/bigint_felt.rs +++ b/felt/src/bigint_felt.rs @@ -1,9 +1,8 @@ -use lazy_static::lazy_static; -use num_bigint::{BigInt, BigUint, ToBigInt, U64Digits}; -use num_integer::Integer; -use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; -use serde::{Deserialize, Serialize}; -use std::{ +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use alloc::{string::String, vec::Vec}; + +use core::{ + cmp, convert::Into, fmt, iter::Sum, @@ -17,6 +16,11 @@ use crate::{FeltOps, ParseFeltError}; pub const FIELD_HIGH: u128 = (1 << 123) + (17 << 64); // this is equal to 10633823966279327296825105735305134080 pub const FIELD_LOW: u128 = 1; +use lazy_static::lazy_static; +use num_bigint::{BigInt, BigUint, ToBigInt, U64Digits}; +use num_integer::Integer; +use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; +use serde::{Deserialize, Serialize}; lazy_static! { static ref CAIRO_PRIME_BIGUINT: BigUint = @@ -148,10 +152,12 @@ impl FeltOps for FeltBigInt { self.val.iter_u64_digits() } + #[cfg(any(feature = "std", feature = "alloc"))] fn to_signed_bytes_le(&self) -> Vec { self.val.to_bytes_le() } + #[cfg(any(feature = "std", feature = "alloc"))] fn to_bytes_be(&self) -> Vec { self.val.to_bytes_be() } @@ -171,6 +177,7 @@ impl FeltOps for FeltBigInt { Self::from(value) } + #[cfg(any(feature = "std", feature = "alloc"))] fn to_str_radix(&self, radix: u32) -> String { self.val.to_str_radix(radix) } @@ -627,7 +634,7 @@ impl Integer for FeltBigInt { } fn lcm(&self, other: &Self) -> Self { - Self::new(std::cmp::max(&self.val, &other.val)) + Self::new(cmp::max(&self.val, &other.val)) } fn mod_floor(&self, other: &Self) -> Self { @@ -829,8 +836,15 @@ mod tests { use super::*; use proptest::prelude::*; + #[cfg(all(not(feature = "std"), feature = "alloc"))] + use alloc::string::ToString; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] // Tests that the result of adding two zeros is zero. + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_zeros() { let a = FeltBigInt::::new(0); let b = FeltBigInt::new(0); @@ -840,6 +854,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of performing add assign with two zeros is zero. fn add_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -898,6 +913,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of multiplying two zeros is zero. fn mul_zeros() { let a = FeltBigInt::::new(0); @@ -908,6 +924,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of multiplying two zeros with assignment is zero. fn mul_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -919,6 +936,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of subtracting two zeros is zero. fn sub_zeros() { let a = FeltBigInt::::new(0); @@ -929,6 +947,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of subtracting two zeros with assignment is zero. fn sub_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -940,6 +959,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_usize_felt() { let a = FeltBigInt::::new(4u32); let b = FeltBigInt::new(2u32); @@ -949,6 +969,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the negative of zero is zero fn negate_zero() { let a = FeltBigInt::::new(0); diff --git a/felt/src/lib.rs b/felt/src/lib.rs index 8c13790d4a..a94818c89b 100644 --- a/felt/src/lib.rs +++ b/felt/src/lib.rs @@ -1,3 +1,9 @@ +#![cfg_attr(not(feature = "std"), no_std)] +#[allow(unused_imports)] +#[macro_use] +#[cfg(all(not(feature = "std"), feature = "alloc"))] +pub extern crate alloc; + mod bigint_felt; use bigint_felt::{FeltBigInt, FIELD_HIGH, FIELD_LOW}; @@ -5,7 +11,8 @@ use num_bigint::{BigInt, BigUint, U64Digits}; use num_integer::Integer; use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; use serde::{Deserialize, Serialize}; -use std::{ + +use core::{ convert::Into, fmt, iter::Sum, @@ -15,6 +22,9 @@ use std::{ }, }; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use alloc::{string::String, vec::Vec}; + pub const PRIME_STR: &str = "0x800000000000011000000000000000000000000000000000000000000000001"; // in decimal, this is equal to 3618502788666131213697322783095070105623107215331596699973092056135872020481 pub(crate) trait FeltOps { @@ -28,14 +38,17 @@ pub(crate) trait FeltOps { fn iter_u64_digits(&self) -> U64Digits; + #[cfg(any(feature = "std", feature = "alloc"))] fn to_signed_bytes_le(&self) -> Vec; + #[cfg(any(feature = "std", feature = "alloc"))] fn to_bytes_be(&self) -> Vec; fn parse_bytes(buf: &[u8], radix: u32) -> Option>; fn from_bytes_be(bytes: &[u8]) -> Self; + #[cfg(any(feature = "std", feature = "alloc"))] fn to_str_radix(&self, radix: u32) -> String; #[deprecated] @@ -138,9 +151,11 @@ impl Felt { pub fn iter_u64_digits(&self) -> U64Digits { self.value.iter_u64_digits() } + #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_signed_bytes_le(&self) -> Vec { self.value.to_signed_bytes_le() } + #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_bytes_be(&self) -> Vec { self.value.to_bytes_be() } @@ -154,6 +169,7 @@ impl Felt { value: FeltBigInt::from_bytes_be(bytes), } } + #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_str_radix(&self, radix: u32) -> String { self.value.to_str_radix(radix) } @@ -824,6 +840,7 @@ assert_felt_impl!(Felt); #[cfg(test)] mod test { use super::*; + use core::cmp; use proptest::prelude::*; const FELT_PATTERN: &str = "(0|[1-9][0-9]*)"; @@ -832,6 +849,7 @@ mod test { proptest! { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a new felt doesn't fall outside the range [0, p]. // In this and some of the following tests, The value of {x} can be either [0] or a very large number, in order to try to overflow the value of {p} and thus ensure the modular arithmetic is working correctly. fn new_in_range(ref x in "(0|[1-9][0-9]*)") { @@ -841,6 +859,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a felt created using Felt::from_bytes_be doesn't fall outside the range [0, p]. // In this and some of the following tests, The value of {x} can be either [0] or a very large number, in order to try to overflow the value of {p} and thus ensure the modular arithmetic is working correctly. fn from_bytes_be_in_range(ref x in "(0|[1-9][0-9]*)") { @@ -851,6 +870,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that the negative of a felt doesn't fall outside the range [0, p]. fn neg_in_range(ref x in "(0|[1-9][0-9]*)") { let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -868,6 +888,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a subtraction between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn sub_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -881,6 +902,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a subtraction with assignment between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn sub_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -899,6 +921,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a multiplication between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn mul_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -912,6 +935,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 pairs of {x} and {y} values that are randomly generated each time tests are run, that a multiplication with assignment between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn mul_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -925,6 +949,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 pairs of {x} and {y} values that are randomly generated each time tests are run, that the result of the division of {x} by {y} is the inverse multiplicative of {x} --that is, multiplying the result by {y} returns the original number {x}. The values of {x} and {y} can be either [0] or a very large number. fn div_is_mul_inv(ref x in "(0|[1-9][0-9]*)", ref y in "[1-9][0-9]*") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -940,6 +965,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the left by {shift_amount} of bits (between 0 and 999) returns a result that is inside of the range [0, p]. fn shift_left_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ let value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); @@ -955,6 +981,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the right by {shift_amount} of bits (between 0 and 999) returns a result that is inside of the range [0, p]. fn shift_right_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ let value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); @@ -966,6 +993,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the right by {shift_amount} of bits (between 0 and 999), with assignment, returns a result that is inside of the range [0, p]. // "With assignment" means that the result of the operation is autommatically assigned to the variable value, replacing its previous content. fn shift_right_assign_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ @@ -978,6 +1006,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitAnd operation between them returns a result that is inside of the range [0, p]. fn bitand_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -990,6 +1019,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitOr operation between them returns a result that is inside of the range [0, p]. fn bitor_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1001,6 +1031,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitXor operation between them returns a result that is inside of the range [0, p]. fn bitxor_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1012,6 +1043,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 values {x} that are randomly generated each time tests are run, that raising {x} to the {y}th power returns a result that is inside of the range [0, p]. fn pow_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "[0-9]{1,2}"){ let base = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1029,6 +1061,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a Sum operation between them returns a result that is inside of the range [0, p]. fn sum_in_range(ref x in "[1-9][0-9]*", ref y in "[0-9][0-9]*"){ let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1041,6 +1074,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property test to check that the remainder of a division between 100 pairs of values {x} and {y},generated at random each time tests are run, falls in the range [0, p]. x and y can either take the value of 0 or a large integer. // In Cairo, the result of x / y is defined to always satisfy the equation (x / y) * y == x, so the remainder is 0 most of the time. fn rem_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { @@ -1059,15 +1093,17 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 Felts {x} generated at random each time tests are run, that converting them into the u64 type returns a result that is inside of the range [0, p]. fn from_u64_and_to_u64_primitive(x in any::()) { let x_felt:Felt = Felt::from_u64(x).unwrap(); let x_u64:u64 = Felt::to_u64(&x_felt).unwrap(); - prop_assert_eq!(x, x_u64); + prop_assert_eq!(x, x_u64); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_i64_and_to_i64_primitive(x in any::()) { let x: i64 = x as i64; let x_felt:Felt = Felt::from_i64(x).unwrap(); @@ -1082,16 +1118,17 @@ mod test { let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); let lcm = x.lcm(&y); - prop_assert!(lcm == std::cmp::max(x, y)); + prop_assert!(lcm == cmp::max(x, y)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property test to check that is_multiple_of(x, y) works. Since we're operating in a prime field, is_multiple_of // will always be true fn is_multiple_of_doesnt_panic(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); - prop_assert!(x.is_multiple_of(&y)); + let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + prop_assert!(x.is_multiple_of(&y)); } #[test] @@ -1293,6 +1330,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of adding two zeroes is zero fn sum_zeros_in_range() { let x = Felt::new(0); @@ -1302,6 +1340,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of multiplying two zeroes is zero fn mul_zeros_in_range() { let x = Felt::new(0); @@ -1311,6 +1350,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of performing a bit and operation between zeroes is zero fn bit_and_zeros_in_range() { let x = Felt::new(0); @@ -1320,6 +1360,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of perfforming a bit or operation between zeroes is zero fn bit_or_zeros_in_range() { let x = Felt::new(0); @@ -1329,6 +1370,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of perfforming a bit xor operation between zeroes is zero fn bit_xor_zeros_in_range() { let x = Felt::new(0); @@ -1338,6 +1380,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the maximum value a Felt can take is equal to (prime - 1) fn upper_bound() { let prime = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); @@ -1347,6 +1390,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the minimum value a Felt can take is equal to zero. fn lower_bound() { let zero = BigUint::zero(); diff --git a/src/cairo_run.rs b/src/cairo_run.rs index cb50860a0e..7c6784cdc0 100644 --- a/src/cairo_run.rs +++ b/src/cairo_run.rs @@ -2,26 +2,24 @@ use crate::{ hint_processor::hint_processor_definition::HintProcessor, types::program::Program, vm::{ - errors::{ - cairo_run_errors::CairoRunError, runner_errors::RunnerError, vm_exception::VmException, - }, + errors::{cairo_run_errors::CairoRunError, vm_exception::VmException}, runners::cairo_runner::CairoRunner, security::verify_secure_runner, - trace::trace_entry::RelocatedTraceEntry, vm_core::VirtualMachine, }, }; + +use bincode::enc::write::Writer; use felt::Felt; -use std::{ - fs::File, - io::{self, BufWriter, Error, ErrorKind, Write}, - path::Path, -}; + +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(not(feature = "std"))] +use thiserror_no_std::Error; pub struct CairoRunConfig<'a> { pub entrypoint: &'a str, pub trace_enabled: bool, - pub print_output: bool, pub layout: &'a str, pub proof_mode: bool, pub secure_run: Option, @@ -32,7 +30,6 @@ impl<'a> Default for CairoRunConfig<'a> { CairoRunConfig { entrypoint: "main", trace_enabled: false, - print_output: false, layout: "plain", proof_mode: false, secure_run: None, @@ -41,14 +38,11 @@ impl<'a> Default for CairoRunConfig<'a> { } pub fn cairo_run( - path: &Path, + program_content: &[u8], cairo_run_config: &CairoRunConfig, hint_executor: &mut dyn HintProcessor, -) -> Result { - let program = match Program::from_file(path, Some(cairo_run_config.entrypoint)) { - Ok(program) => program, - Err(error) => return Err(CairoRunError::Program(error)), - }; +) -> Result<(CairoRunner, VirtualMachine), CairoRunError> { + let program = Program::from_bytes(program_content, Some(cairo_run_config.entrypoint))?; let secure_run = cairo_run_config .secure_run @@ -77,93 +71,81 @@ pub fn cairo_run( } cairo_runner.relocate(&mut vm)?; - if cairo_run_config.print_output { - write_output(&mut cairo_runner, &mut vm)?; - } - - Ok(cairo_runner) + Ok((cairo_runner, vm)) } -pub fn write_output( - cairo_runner: &mut CairoRunner, - vm: &mut VirtualMachine, -) -> Result<(), CairoRunError> { - let mut buffer = BufWriter::new(io::stdout()); - writeln!(&mut buffer, "Program Output: ") - .map_err(|_| CairoRunError::Runner(RunnerError::WriteFail))?; - cairo_runner.write_output(vm, &mut buffer)?; - buffer - .flush() - .map_err(|_| CairoRunError::Runner(RunnerError::WriteFail)) -} - -/// Writes a trace as a binary file. Bincode encodes to little endian by default and each trace -/// entry is composed of 3 usize values that are padded to always reach 64 bit size. -pub fn write_binary_trace( - relocated_trace: &[RelocatedTraceEntry], - trace_file: &Path, -) -> io::Result<()> { - let file = File::create(trace_file)?; - let mut buffer = BufWriter::new(file); - +#[derive(Debug, Error)] +#[error("Failed to encode trace at position {0}, serialize error: {1}")] +pub struct EncodeTraceError(usize, bincode::error::EncodeError); + +/// Writes the trace binary representation. +/// +/// Bincode encodes to little endian by default and each trace entry is composed of +/// 3 usize values that are padded to always reach 64 bit size. +pub fn write_encoded_trace( + relocated_trace: &[crate::vm::trace::trace_entry::RelocatedTraceEntry], + dest: &mut impl Writer, +) -> Result<(), EncodeTraceError> { for (i, entry) in relocated_trace.iter().enumerate() { - bincode::serialize_into(&mut buffer, entry).map_err(|e| { - Error::new( - ErrorKind::Other, - format!("Failed to dump trace at position {i}, serialize error: {e}"), - ) - })?; + bincode::serde::encode_into_writer(entry, &mut *dest, bincode::config::legacy()) + .map_err(|e| EncodeTraceError(i, e))?; } - buffer.flush() + Ok(()) } -/* - Writes a binary memory file with the relocated memory as input. - The memory pairs (address, value) are encoded and concatenated in the file - given by the path `memory_file`. - - * address -> 8-byte encoded - * value -> 32-byte encoded -*/ -pub fn write_binary_memory( +/// Writes a binary representation of the relocated memory. +/// +/// The memory pairs (address, value) are encoded and concatenated: +/// * address -> 8-byte encoded +/// * value -> 32-byte encoded +pub fn write_encoded_memory( relocated_memory: &[Option], - memory_file: &Path, -) -> io::Result<()> { - let file = File::create(memory_file)?; - let mut buffer = BufWriter::new(file); - + dest: &mut impl Writer, +) -> Result<(), EncodeTraceError> { // initialize bytes vector that will be dumped to file - let mut memory_bytes: Vec = Vec::new(); for (i, memory_cell) in relocated_memory.iter().enumerate() { match memory_cell { None => continue, Some(unwrapped_memory_cell) => { - encode_relocated_memory(&mut memory_bytes, i, unwrapped_memory_cell); + encode_relocated_memory(dest, i, unwrapped_memory_cell) + .map_err(|e| EncodeTraceError(i, e))?; } } } - buffer.write_all(&memory_bytes)?; - buffer.flush() + Ok(()) } // encodes a given memory cell. -fn encode_relocated_memory(memory_bytes: &mut Vec, addr: usize, memory_cell: &Felt) { +fn encode_relocated_memory( + dest: &mut impl Writer, + addr: usize, + memory_cell: &Felt, +) -> Result<(), bincode::error::EncodeError> { + let config = bincode::config::standard() + .with_little_endian() + .with_fixed_int_encoding() + .skip_fixed_array_length(); + // append memory address to bytes vector using a 8 bytes representation - let mut addr_bytes = (addr as u64).to_le_bytes().to_vec(); - memory_bytes.append(&mut addr_bytes); + let addr_bytes: [u8; 8] = (addr as u64).to_le_bytes(); + bincode::encode_into_writer(addr_bytes, &mut *dest, config)?; // append memory value at address using a 32 bytes representation - let mut value_bytes = memory_cell.to_signed_bytes_le(); - value_bytes.resize(32, 0); - memory_bytes.append(&mut value_bytes); + let value_bytes = memory_cell.to_signed_bytes_le(); + let mut x = [0; 32]; + x[..value_bytes.len()].copy_from_slice(&value_bytes); + bincode::encode_into_writer(x, &mut *dest, config)?; + + Ok(()) } #[cfg(test)] mod tests { use super::*; + use crate::stdlib::prelude::*; use crate::{ hint_processor::{ builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -171,15 +153,17 @@ mod tests { }, utils::test_utils::*, }; - use std::io::Read; + use bincode::enc::write::SliceWriter; + use felt::Felt; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; fn run_test_program( - program_path: &Path, + program_content: &[u8], hint_processor: &mut dyn HintProcessor, ) -> Result<(CairoRunner, VirtualMachine), CairoRunError> { - let program = - Program::from_file(program_path, Some("main")).map_err(CairoRunError::Program)?; - + let program = Program::from_bytes(program_content, Some("main")).unwrap(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(true); let end = cairo_runner @@ -194,9 +178,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_custom_entry_point() { - let program_path = Path::new("cairo_programs/not_main.json"); - let program = Program::from_file(program_path, Some("not_main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../cairo_programs/not_main.json"), + Some("not_main"), + ) + .unwrap(); let mut vm = vm!(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); @@ -211,72 +199,65 @@ mod tests { assert_eq!(cairo_runner.relocated_memory[2], Some(Felt::new(123))); } - fn compare_files(file_path_1: &Path, file_path_2: &Path) -> io::Result<()> { - let mut file_1 = File::open(file_path_1)?; - let mut file_2 = File::open(file_path_2)?; - - let mut buffer_1 = Vec::new(); - let mut buffer_2 = Vec::new(); - - file_1.read_to_end(&mut buffer_1)?; - file_2.read_to_end(&mut buffer_2)?; - - assert_eq!(&buffer_1.len(), &buffer_2.len()); - - for (buf_byte_1, buf_byte_2) in buffer_1.iter().zip(buffer_2.iter()) { - assert_eq!(buf_byte_1, buf_byte_2); - } - Ok(()) - } - #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_no_data_program() { // a compiled program with no `data` key. // it should fail when the program is loaded. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let no_data_program_path = Path::new("cairo_programs/no_data_program.json"); + let no_data_program_path = + include_bytes!("../cairo_programs/manually_compiled/no_data_program.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(no_data_program_path, &cairo_run_config, &mut hint_processor).is_err()); + assert!(cairo_run(no_data_program_path, &cairo_run_config, &mut hint_processor,).is_err()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_no_main_program() { // a compiled program with no main scope // it should fail when trying to run initialize_main_entrypoint. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let no_main_program_path = Path::new("cairo_programs/no_main_program.json"); + let no_main_program = + include_bytes!("../cairo_programs/manually_compiled/no_main_program.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(no_main_program_path, &cairo_run_config, &mut hint_processor).is_err()); + assert!(cairo_run(no_main_program, &cairo_run_config, &mut hint_processor,).is_err()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_invalid_memory() { // the program invalid_memory.json has an invalid memory cell and errors when trying to // decode the instruction. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let invalid_memory = Path::new("cairo_programs/invalid_memory.json"); + let invalid_memory = + include_bytes!("../cairo_programs/manually_compiled/invalid_memory.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(invalid_memory, &cairo_run_config, &mut hint_processor).is_err()); + assert!(cairo_run(invalid_memory, &cairo_run_config, &mut hint_processor,).is_err()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_output_program() { - let program_path = Path::new("cairo_programs/bitwise_output.json"); + let program_content = include_bytes!("../cairo_programs/bitwise_output.json"); let mut hint_processor = BuiltinHintProcessor::new_empty(); - let (mut cairo_runner, mut vm) = run_test_program(program_path, &mut hint_processor) + let (_, mut vm) = run_test_program(program_content, &mut hint_processor) .expect("Couldn't initialize cairo runner"); - assert!(write_output(&mut cairo_runner, &mut vm).is_ok()); + + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "0\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_binary_trace_file() { - let program_path = Path::new("cairo_programs/struct.json"); - let expected_trace_path = Path::new("cairo_programs/trace_memory/cairo_trace_struct"); - let cairo_rs_trace_path = Path::new("cairo_programs/trace_memory/struct_cairo_rs.trace"); + let program_content = include_bytes!("../cairo_programs/struct.json"); + let expected_encoded_trace = + include_bytes!("../cairo_programs/trace_memory/cairo_trace_struct"); // run test program until the end let mut hint_processor = BuiltinHintProcessor::new_empty(); - let cairo_runner_result = run_test_program(program_path, &mut hint_processor); + let cairo_runner_result = run_test_program(program_content, &mut hint_processor); let (mut cairo_runner, mut vm) = cairo_runner_result.unwrap(); // relocate memory so we can dump it to file @@ -284,40 +265,49 @@ mod tests { assert!(vm.trace.is_some()); assert!(cairo_runner.relocated_trace.is_some()); + let trace_entries = cairo_runner.relocated_trace.unwrap(); + let mut buffer = [0; 24]; + let mut buff_writer = SliceWriter::new(&mut buffer); // write cairo_rs vm trace file - assert!( - write_binary_trace(&cairo_runner.relocated_trace.unwrap(), cairo_rs_trace_path).is_ok() - ); + write_encoded_trace(&trace_entries, &mut buff_writer).unwrap(); // compare that the original cairo vm trace file and cairo_rs vm trace files are equal - assert!(compare_files(cairo_rs_trace_path, expected_trace_path).is_ok()); + assert_eq!(buffer, *expected_encoded_trace); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_binary_memory_file() { - let program_path = Path::new("cairo_programs/struct.json"); - let expected_memory_path = Path::new("cairo_programs/trace_memory/cairo_memory_struct"); - let cairo_rs_memory_path = Path::new("cairo_programs/trace_memory/struct_cairo_rs.memory"); + let program_content = include_bytes!("../cairo_programs/struct.json"); + let expected_encoded_memory = + include_bytes!("../cairo_programs/trace_memory/cairo_memory_struct"); // run test program until the end let mut hint_processor = BuiltinHintProcessor::new_empty(); - let cairo_runner_result = run_test_program(program_path, &mut hint_processor); + let cairo_runner_result = run_test_program(program_content, &mut hint_processor); let (mut cairo_runner, mut vm) = cairo_runner_result.unwrap(); // relocate memory so we can dump it to file assert!(cairo_runner.relocate(&mut vm).is_ok()); + let mut buffer = [0; 120]; + let mut buff_writer = SliceWriter::new(&mut buffer); // write cairo_rs vm memory file - assert!(write_binary_memory(&cairo_runner.relocated_memory, cairo_rs_memory_path).is_ok()); + write_encoded_memory(&cairo_runner.relocated_memory, &mut buff_writer).unwrap(); // compare that the original cairo vm memory file and cairo_rs vm memory files are equal - assert!(compare_files(cairo_rs_memory_path, expected_memory_path).is_ok()); + assert_eq!(*expected_encoded_memory, buffer); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_with_no_trace() { - let program_path = Path::new("cairo_programs/struct.json"); - let program = Program::from_file(program_path, Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../cairo_programs/struct.json"), + Some("main"), + ) + .unwrap(); + let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/blake2s_hash.rs b/src/hint_processor/builtin_hint_processor/blake2s_hash.rs index 808d50f5c8..53515fd969 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_hash.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_hash.rs @@ -1,4 +1,4 @@ -use std::ops::Shl; +use crate::stdlib::{ops::Shl, prelude::*}; pub const IV: [u32; 8] = [ 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19, @@ -131,7 +131,11 @@ pub fn blake2s_compress( mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_a() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -151,6 +155,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_b() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -170,6 +175,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_c() { //Hashing "Hello World" let h: [u32; 8] = [ @@ -192,6 +198,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_d() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -214,6 +221,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_e() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -236,6 +244,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_f() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -258,6 +267,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_g() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, diff --git a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs index 7723b41d05..62a6528e85 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -13,7 +15,6 @@ use crate::{ }; use felt::Felt; use num_traits::ToPrimitive; -use std::{borrow::Cow, collections::HashMap}; fn get_fixed_size_u32_array( h_range: &Vec>, @@ -221,9 +222,12 @@ mod tests { vm::{errors::memory_errors::MemoryError, vm_memory::memory::Memory}, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_offset_zero() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -245,6 +249,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_empty_segment() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -266,6 +271,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_not_relocatable() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -285,6 +291,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_input_bigger_than_u32() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -313,6 +320,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_input_relocatable() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -333,6 +341,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_valid() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -379,6 +388,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_invalid_segment_taken() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -404,6 +414,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_invalid_no_ids() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -418,6 +429,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_valid_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.low >> (B * i)) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.high >> (B * i)) & MASK for i in range(4)]"; //Create vm @@ -450,6 +462,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_valid_non_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.low >> (B * i)) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.high >> (B * i)) & MASK for i in range(4)]"; //Create vm @@ -482,6 +495,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_bigend_valid_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.high >> (B * (3 - i))) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.low >> (B * (3 - i))) & MASK for i in range(4)])"; //Create vm @@ -514,6 +528,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_bigend_valid_non_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.high >> (B * (3 - i))) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.low >> (B * (3 - i))) & MASK for i in range(4)])"; //Create vm diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index db4dd67767..6f94342a24 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, collections::HashMap, prelude::*, rc::Rc}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -60,7 +62,6 @@ use crate::{ vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; use felt::Felt; -use std::{any::Any, collections::HashMap, rc::Rc}; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; @@ -447,6 +448,7 @@ impl HintProcessor for BuiltinHintProcessor { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::any::Any; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -461,9 +463,12 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::{One, Zero}; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_empty_memory() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -477,6 +482,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_preset_memory() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -492,6 +498,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_ap_is_not_empty() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -516,6 +523,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unknown_hint() { let hint_code = "random_invalid_code"; let mut vm = vm!(); @@ -526,6 +534,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_enter_scope_valid() { let hint_code = "vm_enter_scope({'n': ids.len})"; let mut vm = vm!(); @@ -540,6 +549,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_enter_scope_invalid() { let hint_code = "vm_enter_scope({'n': ids.len})"; let mut vm = vm!(); @@ -560,6 +570,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_valid() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -577,6 +588,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_variable_not_in_scope_error() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -595,6 +607,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_insert_error() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -624,6 +637,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_valid() { let hint_code = "vm_exit_scope()"; let mut vm = vm!(); @@ -637,6 +651,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_invalid() { let hint_code = "vm_exit_scope()"; let mut vm = vm!(); @@ -652,6 +667,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_enter_scope() { let hint_code = "vm_enter_scope()"; //Create vm @@ -669,6 +685,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_valid() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -691,6 +708,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_max_size() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -715,6 +733,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_invalid_input_length() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -736,6 +755,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_invalid_word_size() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -761,6 +781,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_valid() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -781,6 +802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_nones_in_range() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -803,6 +825,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_expected_integer_at_range() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -834,6 +857,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_hint_add_same_hint_twice() { let mut hint_processor = BuiltinHintProcessor::new_empty(); let hint_func = Rc::new(HintFunc(Box::new(enter_scope))); diff --git a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs index a6a0646f7e..b9cd8c0142 100644 --- a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs +++ b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs @@ -1,3 +1,8 @@ +use crate::stdlib::{ + borrow::{Cow, ToOwned}, + collections::HashMap, + prelude::*, +}; use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -14,7 +19,6 @@ use crate::{ }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; -use std::{borrow::Cow, collections::HashMap}; // Constants in package "starkware.cairo.common.cairo_keccak.keccak". const BYTES_IN_WORD: &str = "starkware.cairo.common.cairo_keccak.keccak.BYTES_IN_WORD"; @@ -252,6 +256,7 @@ pub fn u64_array_to_mayberelocatable_vec(array: &[u64]) -> Vec #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -269,9 +274,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn keccak_write_args_valid_test() { let hint_code = "segments.write_arg(ids.inputs, [ids.low % 2 ** 64, ids.low // 2 ** 64])\nsegments.write_arg(ids.inputs + 2, [ids.high % 2 ** 64, ids.high // 2 ** 64])"; let mut vm = vm_with_range_check!(); @@ -289,6 +297,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn keccak_write_args_write_error() { let hint_code = "segments.write_arg(ids.inputs, [ids.low % 2 ** 64, ids.low // 2 ** 64])\nsegments.write_arg(ids.inputs + 2, [ids.high % 2 ** 64, ids.high // 2 ** 64])"; let mut vm = vm_with_range_check!(); @@ -302,6 +311,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compare_bytes_in_word_nondet_valid() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; @@ -328,6 +338,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compare_keccak_full_rate_in_bytes_nondet_valid() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; @@ -356,6 +367,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn block_permutation_valid_test() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; diff --git a/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs b/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs index ab222d1ecf..3767fce2ff 100644 --- a/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs @@ -1,8 +1,9 @@ +use crate::stdlib::{any::Any, cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; + use crate::{ types::{exec_scope::ExecutionScopes, relocatable::MaybeRelocatable}, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; use crate::{ any_box, @@ -257,6 +258,7 @@ mod tests { use crate::hint_processor::builtin_hint_processor::dict_manager::Dictionary; use crate::hint_processor::builtin_hint_processor::hint_code; use crate::hint_processor::hint_processor_definition::HintProcessor; + use crate::stdlib::collections::HashMap; use crate::types::exec_scope::ExecutionScopes; use crate::vm::vm_memory::memory::Memory; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; @@ -268,9 +270,12 @@ mod tests { vm::{errors::memory_errors::MemoryError, vm_core::VirtualMachine}, }; use assert_matches::assert_matches; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_with_initial_dict_empty() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -302,6 +307,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_with_no_initial_dict() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -313,6 +319,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_ap_is_taken() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -337,6 +344,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_valid() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -364,6 +372,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_invalid_key() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -381,6 +390,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_no_tracker() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -401,6 +411,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_default_dict_new_valid() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_default_dict(segments, ids.default_value)"; let mut vm = vm!(); @@ -432,6 +443,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_default_dict_new_no_default_value() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_default_dict(segments, ids.default_value)"; let mut vm = vm!(); @@ -445,6 +457,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_default_valid_empty_dict() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -472,6 +485,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_default_valid_overwrite_value() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -499,6 +513,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_simple_valid_overwrite_value() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -527,6 +542,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_simple_valid_cant_write_new_key() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -551,6 +567,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_valid() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -575,6 +592,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_valid_no_change() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -599,6 +617,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_invalid_wrong_prev_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -628,6 +647,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_invalid_wrong_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -651,6 +671,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -675,6 +696,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid_no_change() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -699,6 +721,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_invalid_wrong_prev_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -728,6 +751,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_invalid_wrong_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -757,6 +781,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid_no_key_prev_value_equals_default() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -781,6 +806,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_valid_empty_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -809,6 +835,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_valid_non_empty_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -840,6 +867,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_invalid_no_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -860,6 +888,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_no_tracker() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -880,6 +909,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_valid() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -899,6 +929,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_mismatched_dict_ptr() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -921,6 +952,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_valid_relocatable_new_value() { let mut vm = vm!(); //Initialize fp diff --git a/src/hint_processor/builtin_hint_processor/dict_manager.rs b/src/hint_processor/builtin_hint_processor/dict_manager.rs index 5d1b1ff5a9..28102ac887 100644 --- a/src/hint_processor/builtin_hint_processor/dict_manager.rs +++ b/src/hint_processor/builtin_hint_processor/dict_manager.rs @@ -1,4 +1,4 @@ -use std::collections::HashMap; +use crate::stdlib::collections::HashMap; use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, @@ -202,13 +202,18 @@ mod tests { use crate::{relocatable, utils::test_utils::*, vm::vm_core::VirtualMachine}; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_manager() { let dict_manager = DictManager::new(); assert_eq!(dict_manager.trackers, HashMap::new()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_tracker_empty() { let dict_tracker = DictTracker::new_empty(relocatable!(1, 0)); assert_eq!( @@ -219,6 +224,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_tracker_default() { let dict_tracker = DictTracker::new_default_dict(relocatable!(1, 0), &MaybeRelocatable::from(5), None); @@ -233,6 +239,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_empty() { let mut vm = vm!(); let mut dict_manager = DictManager::new(); @@ -247,6 +254,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_default() { let mut dict_manager = DictManager::new(); let mut vm = vm!(); @@ -265,6 +273,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_with_initial_dict() { let mut dict_manager = DictManager::new(); let mut vm = vm!(); @@ -284,6 +293,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_default_dict_with_initial_dict() { let mut dict_manager = DictManager::new(); let mut initial_dict = HashMap::::new(); @@ -308,6 +318,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_empty_same_segment() { let mut dict_manager = DictManager::new(); dict_manager @@ -321,6 +332,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_default_dict_empty_same_segment() { let mut dict_manager = DictManager::new(); dict_manager.trackers.insert( @@ -335,6 +347,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dictionary_get_insert_simple() { let mut dictionary = Dictionary::SimpleDictionary(HashMap::new()); dictionary.insert(&MaybeRelocatable::from(1), &MaybeRelocatable::from(2)); @@ -346,6 +359,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dictionary_get_insert_default() { let mut dictionary = Dictionary::DefaultDictionary { dict: HashMap::new(), diff --git a/src/hint_processor/builtin_hint_processor/find_element_hint.rs b/src/hint_processor/builtin_hint_processor/find_element_hint.rs index 1e559fa252..cd0b013b3a 100644 --- a/src/hint_processor/builtin_hint_processor/find_element_hint.rs +++ b/src/hint_processor/builtin_hint_processor/find_element_hint.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -13,7 +15,6 @@ use crate::{ }; use felt::Felt; use num_traits::{Signed, ToPrimitive}; -use std::collections::HashMap; pub fn find_element( vm: &mut VirtualMachine, @@ -132,6 +133,7 @@ pub fn search_sorted_lower( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::{ any_box, hint_processor::{ @@ -147,7 +149,9 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::{One, Zero}; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; fn init_vm_ids_data( values_to_override: HashMap, @@ -217,16 +221,15 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_found_by_search() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); - assert_matches!( - run_hint!(vm, ids_data, hint_code::FIND_ELEMENT.to_string()), - Ok(()) - ); + assert_matches!(run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), Ok(())); check_memory![vm.segments.memory, ((1, 3), 1)]; } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_found_by_oracle() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_index", Felt::one())]; @@ -238,6 +241,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_not_found_search() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "key".to_string(), @@ -250,6 +254,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_not_found_oracle() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_index", Felt::new(2))]; @@ -260,6 +265,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_failed_ids_get_from_mem() { let mut vm = vm!(); vm.run_context.fp = 5; @@ -272,6 +278,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_not_int_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -285,6 +292,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_zero_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -297,6 +305,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_negative_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -309,6 +318,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_not_int_n_elms() { let relocatable = MaybeRelocatable::from((1, 2)); let (mut vm, ids_data) = @@ -321,6 +331,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_negative_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -333,12 +344,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_empty_scope() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!(run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), Ok(())); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_n_elms_gt_max_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_max_size", Felt::one())]; @@ -349,6 +362,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_key_not_int() { let relocatable = MaybeRelocatable::from((1, 4)); let (mut vm, ids_data) = @@ -360,6 +374,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!( @@ -371,6 +386,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_no_matches() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "key".to_string(), @@ -384,6 +400,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_not_int_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -397,6 +414,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_zero_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -409,6 +427,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_negative_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -421,6 +440,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_not_int_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -434,6 +454,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_negative_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -446,6 +467,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_empty_scope() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!( @@ -455,6 +477,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_n_elms_gt_max_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_max_size", Felt::one())]; diff --git a/src/hint_processor/builtin_hint_processor/hint_utils.rs b/src/hint_processor/builtin_hint_processor/hint_utils.rs index eb31045b2a..796ebe2911 100644 --- a/src/hint_processor/builtin_hint_processor/hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/hint_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; + use felt::Felt; use crate::hint_processor::hint_processor_definition::HintReference; @@ -12,8 +14,6 @@ use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; use crate::vm::errors::hint_errors::HintError; use crate::vm::vm_core::VirtualMachine; -use std::borrow::Cow; -use std::collections::HashMap; //Inserts value into the address of the given ids variable pub fn insert_value_from_var_name( @@ -122,6 +122,7 @@ pub fn get_reference_from_var_name<'a>( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ hint_processor::hint_processor_definition::HintReference, @@ -134,7 +135,11 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_immediate_value() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -149,6 +154,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -162,6 +168,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_var_name_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); @@ -175,6 +182,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -188,6 +196,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -202,6 +211,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -215,6 +225,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_from_var_name_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); @@ -228,6 +239,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 1)]; @@ -241,6 +253,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 38a5bb348c..af2c259fdf 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{cmp, collections::HashMap, ops::Shl, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -12,7 +14,6 @@ use crate::{ use felt::Felt; use num_traits::{One, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; -use std::{cmp, collections::HashMap, ops::Shl}; /* Implements hint: %{ diff --git a/src/hint_processor/builtin_hint_processor/math_utils.rs b/src/hint_processor/builtin_hint_processor/math_utils.rs index f99246b10e..8a12232418 100644 --- a/src/hint_processor/builtin_hint_processor/math_utils.rs +++ b/src/hint_processor/builtin_hint_processor/math_utils.rs @@ -1,4 +1,11 @@ +use crate::stdlib::{ + collections::HashMap, + ops::{Shl, Shr}, + prelude::*, +}; + use crate::utils::CAIRO_PRIME; + use crate::{ any_box, hint_processor::{ @@ -21,11 +28,6 @@ use num_bigint::BigUint; use num_integer::Integer; use num_traits::One; use num_traits::{Signed, Zero}; -use std::{ - any::Any, - collections::HashMap, - ops::{Shl, Shr}, -}; use super::hint_utils::get_maybe_relocatable_from_var_name; @@ -536,6 +538,7 @@ fn div_prime_by_bound(bound: Felt) -> Result { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::ops::Shl; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -556,9 +559,12 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::Zero; - use std::{any::Any, ops::Shl}; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_false() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -576,6 +582,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_true() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -593,6 +600,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] //This test contemplates the case when the number itself is negative, but it is within the range (-prime, -range_check_bound) //Making the comparison return 1 (true) fn run_is_nn_hint_true_border_case() { @@ -617,6 +625,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_no_range_check_builtin() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm!(); @@ -636,6 +645,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_incorrect_ids() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -651,6 +661,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_cant_get_ids_from_memory() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -669,6 +680,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_ids_are_relocatable_values() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -687,6 +699,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_le_felt_valid() { let hint_code = ASSERT_LE_FELT; let mut constants = HashMap::new(); @@ -716,6 +729,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_le_felt_hint_true() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm_with_range_check!(); @@ -732,6 +746,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_le_felt_hint_inconsistent_memory() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm_with_range_check!(); @@ -756,6 +771,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_le_felt_hint_incorrect_ids() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm!(); @@ -770,6 +786,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_valid() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -785,6 +802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_invalid() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -802,6 +820,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -818,6 +837,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_a_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -835,6 +855,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm!(); @@ -853,6 +874,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_reference_is_not_in_memory() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -869,6 +891,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_invalid() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -896,6 +919,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_a_is_not_integer() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -923,6 +947,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_b_is_not_integer() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -950,6 +975,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_out_of_range_false() { let hint_code = "memory[ap] = 0 if 0 <= ((-ids.a - 1) % PRIME) < range_check_builtin.bound else 1"; @@ -967,6 +993,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_out_of_range_true() { let hint_code = "memory[ap] = 0 if 0 <= ((-ids.a - 1) % PRIME) < range_check_builtin.bound else 1"; @@ -983,6 +1010,7 @@ mod tests { check_memory![vm.segments.memory, ((1, 0), 0)]; } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_false() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1003,6 +1031,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1016,6 +1045,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_bignum_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1039,6 +1069,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_false() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1059,6 +1090,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1072,6 +1104,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_non_equal_relocatable_diff_index() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1091,6 +1124,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_and_integer() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1112,6 +1146,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_true() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1127,6 +1162,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_false() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1147,6 +1183,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_incorrect_id() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1164,6 +1201,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_expected_integer_error() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1182,6 +1220,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_assertion_invalid() { let hint_code = "assert ids.value == 0, 'split_int(): value is out of range.'"; let mut vm = vm!(); @@ -1198,6 +1237,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_assertion_valid() { let hint_code = "assert ids.value == 0, 'split_int(): value is out of range.'"; let mut vm = vm!(); @@ -1211,6 +1251,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_valid() { let hint_code = "memory[ids.output] = res = (int(ids.value) % PRIME) % ids.base\nassert res < ids.bound, f'split_int(): Limb {res} is out of range.'"; let mut vm = vm!(); @@ -1226,6 +1267,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_invalid() { let hint_code = "memory[ids.output] = res = (int(ids.value) % PRIME) % ids.base\nassert res < ids.bound, f'split_int(): Limb {res} is out of range.'"; let mut vm = vm!(); @@ -1248,6 +1290,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_true() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1266,6 +1309,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_false() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1283,6 +1327,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_outside_valid_range() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1309,6 +1354,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_is_positive_not_empty() { let hint_code ="from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; let mut vm = vm_with_range_check!(); @@ -1334,6 +1380,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_valid() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1350,6 +1397,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_invalid_negative_number() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1369,6 +1417,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_invalid_mismatched_root() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1394,6 +1443,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_success() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1409,6 +1459,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_out_of_range() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1429,6 +1480,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm!(); @@ -1447,6 +1499,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_inconsitent_memory() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1472,6 +1525,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1489,6 +1543,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_success() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1504,6 +1559,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_negative_quotient() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1519,6 +1575,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_out_of_range() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1539,6 +1596,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm!(); @@ -1557,6 +1615,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_inconsitent_memory() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1582,6 +1641,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1599,6 +1659,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_250_bit_valid() { let hint_code = "from starkware.cairo.common.math_utils import as_int\n\n# Correctness check.\nvalue = as_int(ids.value, PRIME) % PRIME\nassert value < ids.UPPER_BOUND, f'{value} is outside of the range [0, 2**250).'\n\n# Calculation for the assertion.\nids.high, ids.low = divmod(ids.value, ids.SHIFT)"; let mut vm = vm!(); @@ -1616,6 +1677,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_250_bit_invalid() { let hint_code = "from starkware.cairo.common.math_utils import as_int\n\n# Correctness check.\nvalue = as_int(ids.value, PRIME) % PRIME\nassert value < ids.UPPER_BOUND, f'{value} is outside of the range [0, 2**250).'\n\n# Calculation for the assertion.\nids.high, ids.low = divmod(ids.value, ids.SHIFT)"; let mut vm = vm!(); @@ -1640,6 +1702,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_ok() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1668,6 +1731,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1689,6 +1753,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_fails_first_insert() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1723,6 +1788,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_fails_second_insert() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1757,6 +1823,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_value_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1779,6 +1846,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_ok() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1794,6 +1862,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_assert_fails() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1810,6 +1879,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1827,6 +1897,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_a_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1844,6 +1915,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_b_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1861,6 +1933,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_ok_failed_to_get_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; diff --git a/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs b/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs index a7e8d36ad6..4ac912179b 100644 --- a/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -11,7 +13,6 @@ use crate::{ }; use felt::Felt; use num_traits::{One, Zero}; -use std::{any::Any, collections::HashMap}; //Implements hint: memory[ap] = segments.add() pub fn add_segment(vm: &mut VirtualMachine) -> Result<(), HintError> { @@ -82,7 +83,11 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_valid() { let mut vm = vm!(); // initialize memory segments @@ -108,6 +113,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_invalid_expected_integer() { let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/memset_utils.rs b/src/hint_processor/builtin_hint_processor/memset_utils.rs index 8d13dd38da..f915c544f2 100644 --- a/src/hint_processor/builtin_hint_processor/memset_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memset_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -11,7 +13,6 @@ use crate::{ }; use felt::Felt; use num_traits::Signed; -use std::{any::Any, collections::HashMap}; // Implements hint: // %{ vm_enter_scope({'n': ids.n}) %} @@ -56,6 +57,7 @@ pub fn memset_continue_loop( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -72,7 +74,11 @@ mod tests { use assert_matches::assert_matches; use num_traits::{One, Zero}; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_enter_scope_valid() { let hint_code = "vm_enter_scope({'n': ids.n})"; let mut vm = vm!(); @@ -85,6 +91,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_enter_scope_invalid() { let hint_code = "vm_enter_scope({'n': ids.n})"; let mut vm = vm!(); @@ -102,6 +109,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_valid_continue_loop_equal_1() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -119,6 +127,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_valid_continue_loop_equal_5() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -137,6 +146,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_variable_not_in_scope_error() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -158,6 +168,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_insert_error() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/pow_utils.rs b/src/hint_processor/builtin_hint_processor/pow_utils.rs index 6de8b9e877..7986ac277b 100644 --- a/src/hint_processor/builtin_hint_processor/pow_utils.rs +++ b/src/hint_processor/builtin_hint_processor/pow_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -10,7 +12,6 @@ use crate::{ }; use felt::Felt; use num_integer::Integer; -use std::collections::HashMap; /* Implements hint: @@ -53,9 +54,12 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::One; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_ok() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -69,6 +73,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_incorrect_ids() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -85,6 +90,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_incorrect_references() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -101,6 +107,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_prev_locs_exp_is_not_integer() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -119,6 +126,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_invalid_memory_insert() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs b/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs index 68670332bd..4c8d59772e 100644 --- a/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs @@ -1,3 +1,4 @@ +use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -14,7 +15,6 @@ use crate::{ vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; use felt::Felt; -use std::{borrow::Cow, collections::HashMap}; #[derive(Debug, PartialEq)] pub(crate) struct BigInt3<'a> { @@ -109,6 +109,8 @@ mod tests { BuiltinHintProcessor, HintProcessorData, }; use crate::hint_processor::hint_processor_definition::HintProcessor; + use crate::stdlib::ops::Shl; + use crate::stdlib::string::ToString; use crate::types::exec_scope::ExecutionScopes; use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; @@ -120,10 +122,12 @@ mod tests { use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use assert_matches::assert_matches; use num_traits::One; - use std::any::Any; - use std::ops::Shl; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); @@ -160,6 +164,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_value_not_in_scope() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); @@ -175,6 +180,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_split_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs b/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs index cad7bd38a1..5e2cabf9e5 100644 --- a/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs @@ -1,3 +1,8 @@ +use crate::stdlib::{ + collections::HashMap, + ops::{BitAnd, Shl}, + prelude::*, +}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -17,10 +22,6 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::{One, Zero}; -use std::{ - collections::HashMap, - ops::{BitAnd, Shl}, -}; use super::bigint_utils::BigInt3; @@ -330,6 +331,7 @@ pub fn ec_mul_inner( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -350,9 +352,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_negate_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\ny = pack(ids.point.y, PRIME) % SECP_P\n# The modulo operation in python always returns a nonnegative number.\nvalue = (-y) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -396,6 +401,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_compute_doubling_slope_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\nfrom starkware.python.math_utils import ec_double_slope\n\n# Compute the slope.\nx = pack(ids.point.x, PRIME)\ny = pack(ids.point.y, PRIME)\nvalue = slope = ec_double_slope(point=(x, y), alpha=0, p=SECP_P)"; let mut vm = vm_with_range_check!(); @@ -457,6 +463,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_compute_slope_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\nfrom starkware.python.math_utils import line_slope\n\n# Compute the slope.\nx0 = pack(ids.point0.x, PRIME)\ny0 = pack(ids.point0.y, PRIME)\nx1 = pack(ids.point1.x, PRIME)\ny1 = pack(ids.point1.y, PRIME)\nvalue = slope = line_slope(point1=(x0, y0), point2=(x1, y1), p=SECP_P)"; let mut vm = vm_with_range_check!(); @@ -528,6 +535,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_double_assign_new_x_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nslope = pack(ids.slope, PRIME)\nx = pack(ids.point.x, PRIME)\ny = pack(ids.point.y, PRIME)\n\nvalue = new_x = (pow(slope, 2, SECP_P) - 2 * x) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -611,6 +619,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_double_assign_new_y_ok() { let hint_code = "value = new_y = (slope * (x - new_x) - y) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -680,6 +689,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_fast_ec_add_assign_new_x_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nslope = pack(ids.slope, PRIME)\nx0 = pack(ids.point0.x, PRIME)\nx1 = pack(ids.point1.x, PRIME)\ny0 = pack(ids.point0.y, PRIME)\n\nvalue = new_x = (pow(slope, 2, SECP_P) - x0 - x1) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -757,6 +767,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_fast_ec_add_assign_new_y_ok() { let hint_code = "value = new_y = (slope * (x0 - new_x) - y0) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -828,6 +839,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_mul_inner_ok() { let hint_code = "memory[ap] = (ids.scalar % PRIME) % 2"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs index 3fb1a80068..fea37db3ea 100644 --- a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, ops::Shl, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -15,7 +17,6 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::{One, Zero}; -use std::{collections::HashMap, ops::Shl}; use super::{bigint_utils::BigInt3, secp_utils::pack}; @@ -161,6 +162,7 @@ pub fn is_zero_assign_scope_variables( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -181,9 +183,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -221,6 +226,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -258,6 +264,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_invalid_memory_insert() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -303,6 +310,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_reduce_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nvalue = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -355,6 +363,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_reduce_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nvalue = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -393,6 +402,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_pack_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nx = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -448,6 +458,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_pack_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nx = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -487,6 +498,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_ok_true() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -513,6 +525,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_ok_false() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -539,6 +552,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_scope_error() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -559,6 +573,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_invalid_memory_insert() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -588,6 +603,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_assign_scope_variables_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P\nfrom starkware.python.math_utils import div_mod\n\nvalue = x_inv = div_mod(1, x, SECP_P)"; let mut vm = vm_with_range_check!(); @@ -642,6 +658,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_assign_scope_variables_scope_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P\nfrom starkware.python.math_utils import div_mod\n\nvalue = x_inv = div_mod(1, x, SECP_P)"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs b/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs index 7952efd40b..60b0232daf 100644 --- a/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs @@ -1,9 +1,9 @@ +use crate::stdlib::{collections::HashMap, ops::Shl, prelude::*}; + use crate::vm::errors::hint_errors::HintError; use felt::Felt; use num_traits::Zero; -use std::collections::HashMap; -use std::ops::Shl; use super::bigint_utils::BigInt3; @@ -64,16 +64,19 @@ pub(crate) fn pack(num: BigInt3) -> num_bigint::BigInt { #[cfg(test)] mod tests { - use std::borrow::Cow; - use super::*; + use crate::stdlib::{borrow::Cow, string::ToString}; use crate::utils::test_utils::*; use assert_matches::assert_matches; use felt::felt_str; use num_bigint::BigUint; use num_traits::One; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn secp_split() { let mut constants = HashMap::new(); constants.insert(BASE_86.to_string(), Felt::one() << 86_usize); @@ -144,6 +147,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn secp_pack() { let pack_1 = pack(BigInt3 { d0: Cow::Borrowed(&Felt::new(10_i32)), diff --git a/src/hint_processor/builtin_hint_processor/secp/signature.rs b/src/hint_processor/builtin_hint_processor/secp/signature.rs index 25d3375c70..8364e94c6a 100644 --- a/src/hint_processor/builtin_hint_processor/secp/signature.rs +++ b/src/hint_processor/builtin_hint_processor/secp/signature.rs @@ -1,3 +1,9 @@ +use crate::stdlib::{ + collections::HashMap, + ops::{Shl, Shr}, + prelude::*, +}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -16,10 +22,6 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::One; -use std::{ - collections::HashMap, - ops::{Shl, Shr}, -}; use super::bigint_utils::BigInt3; @@ -148,6 +150,8 @@ pub fn get_point_from_x( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::ops::Shl; + use crate::stdlib::string::ToString; use crate::types::errors::math_errors::MathError; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ @@ -165,9 +169,12 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::Zero; - use std::{any::Any, ops::Shl}; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn safe_div_ok() { let hint_code = hint_code::DIV_MOD_N_PACKED_DIVMOD; let mut vm = vm!(); @@ -200,6 +207,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn safe_div_fail() { let mut exec_scopes = scope![ ("a", BigInt::zero()), @@ -229,6 +237,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_point_from_x_ok() { let hint_code = hint_code::GET_POINT_FROM_X; let mut vm = vm!(); @@ -268,6 +277,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_point_from_x_negative_y() { let hint_code = hint_code::GET_POINT_FROM_X; let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/segments.rs b/src/hint_processor/builtin_hint_processor/segments.rs index 45a779ca26..6ca1e525ff 100644 --- a/src/hint_processor/builtin_hint_processor/segments.rs +++ b/src/hint_processor/builtin_hint_processor/segments.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::hint_processor::builtin_hint_processor::hint_utils::get_ptr_from_var_name; use crate::hint_processor::{ builtin_hint_processor::hint_utils::insert_value_from_var_name, @@ -6,7 +8,6 @@ use crate::hint_processor::{ use crate::serde::deserialize_program::ApTracking; use crate::vm::errors::hint_errors::HintError; use crate::vm::vm_core::VirtualMachine; -use std::collections::HashMap; /* Implements hint: @@ -63,9 +64,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_relocate_segment() { let hint_code = hint_code::RELOCATE_SEGMENT; //Initialize vm @@ -88,6 +92,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_temporary_array() { let hint_code = hint_code::TEMPORARY_ARRAY; //Initialize vm diff --git a/src/hint_processor/builtin_hint_processor/set.rs b/src/hint_processor/builtin_hint_processor/set.rs index 330f1435d3..79ae9984ad 100644 --- a/src/hint_processor/builtin_hint_processor/set.rs +++ b/src/hint_processor/builtin_hint_processor/set.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -11,7 +13,6 @@ use crate::{ }; use felt::Felt; use num_traits::{One, ToPrimitive, Zero}; -use std::collections::HashMap; pub fn set_add( vm: &mut VirtualMachine, @@ -86,7 +87,9 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; const HINT_CODE: &str = "assert ids.elm_size > 0\nassert ids.set_ptr <= ids.set_end_ptr\nelm_list = memory.get_range(ids.elm_ptr, ids.elm_size)\nfor i in range(0, ids.set_end_ptr - ids.set_ptr, ids.elm_size):\n if memory.get_range(ids.set_ptr + i, ids.elm_size) == elm_list:\n ids.index = i // ids.elm_size\n ids.is_elm_in_set = 1\n break\nelse:\n ids.is_elm_in_set = 0"; @@ -130,6 +133,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_add_new_elem() { let (mut vm, ids_data) = init_vm_ids_data(None, None, None, None); assert_matches!(run_hint!(vm, ids_data, HINT_CODE), Ok(())); @@ -144,6 +148,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_add_already_exists() { let (mut vm, ids_data) = init_vm_ids_data(None, None, Some(1), Some(3)); assert_matches!(run_hint!(vm, ids_data, HINT_CODE), Ok(())); @@ -151,6 +156,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn elm_size_negative() { let (mut vm, ids_data) = init_vm_ids_data(None, Some(-2), None, None); assert_matches!( @@ -160,6 +166,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn elm_size_zero() { let (mut vm, ids_data) = init_vm_ids_data(None, Some(0), None, None); assert_matches!( @@ -170,6 +177,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_ptr_gt_set_end_ptr() { let (mut vm, ids_data) = init_vm_ids_data(Some((2, 3)), None, None, None); assert_matches!( diff --git a/src/hint_processor/builtin_hint_processor/sha256_utils.rs b/src/hint_processor/builtin_hint_processor/sha256_utils.rs index ee7f92a31f..096ba782d2 100644 --- a/src/hint_processor/builtin_hint_processor/sha256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/sha256_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -14,7 +16,6 @@ use felt::Felt; use generic_array::GenericArray; use num_traits::{One, Zero}; use sha2::compress256; -use std::collections::HashMap; use crate::hint_processor::hint_processor_definition::HintReference; @@ -129,7 +130,11 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_input_one() { let mut vm = vm_with_range_check!(); vm.segments = segments![((1, 1), 7)]; @@ -141,6 +146,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_input_zero() { let mut vm = vm_with_range_check!(); vm.segments = segments![((1, 1), 3)]; @@ -152,6 +158,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_ok() { let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/signature.rs b/src/hint_processor/builtin_hint_processor/signature.rs index b02011b406..9aa273bba7 100644 --- a/src/hint_processor/builtin_hint_processor/signature.rs +++ b/src/hint_processor/builtin_hint_processor/signature.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use num_integer::Integer; use crate::{ @@ -12,7 +14,6 @@ use crate::{ vm_core::VirtualMachine, }, }; -use std::collections::HashMap; pub fn verify_ecdsa_signature( vm: &mut VirtualMachine, @@ -66,9 +67,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_ecdsa_signature_valid() { let mut vm = vm!(); vm.builtin_runners = vec![( diff --git a/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs b/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs index d12193e669..c4bb1a0ebf 100644 --- a/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs +++ b/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -19,7 +21,6 @@ use crate::{ use felt::Felt; use num_integer::Integer; use num_traits::{One, ToPrimitive, Zero}; -use std::collections::HashMap; fn get_access_indices( exec_scopes: &mut ExecutionScopes, @@ -316,7 +317,9 @@ mod tests { }; use assert_matches::assert_matches; use felt::felt_str; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; //Hint code as consts const SQUASH_DICT_INNER_FIRST_ITERATION : &str = "current_access_indices = sorted(access_indices[key])[::-1]\ncurrent_access_index = current_access_indices.pop()\nmemory[ids.range_check_ptr] = current_access_index"; @@ -332,6 +335,7 @@ mod tests { const SQUASH_DICT_INNER_NEXT_KEY: &str = "assert len(keys) > 0, 'No keys left but remaining_accesses > 0.'\nids.next_key = key = keys.pop()"; const SQUASH_DICT: &str ="dict_access_size = ids.DictAccess.SIZE\naddress = ids.dict_accesses.address_\nassert ids.ptr_diff % dict_access_size == 0, \\\n 'Accesses array size must be divisible by DictAccess.SIZE'\nn_accesses = ids.n_accesses\nif '__squash_dict_max_size' in globals():\n assert n_accesses <= __squash_dict_max_size, \\\n f'squash_dict() can only be used with n_accesses<={__squash_dict_max_size}. ' \\\n f'Got: n_accesses={n_accesses}.'\n# A map from key to the list of indices accessing it.\naccess_indices = {}\nfor i in range(n_accesses):\n key = memory[address + dict_access_size * i]\n access_indices.setdefault(key, []).append(i)\n# Descending list of keys.\nkeys = sorted(access_indices.keys(), reverse=True)\n# Are the keys used bigger than range_check bound.\nids.big_keys = 1 if keys[0] >= range_check_builtin.bound else 0\nids.first_key = key = keys.pop()"; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_valid() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //Prepare scope variables @@ -368,6 +372,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_empty_accessed_indices() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //Prepare scope variables @@ -393,6 +398,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_no_local_variables() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //No scope variables @@ -412,6 +418,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_skip_loop_valid_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_SKIP_LOOP; //Create vm @@ -430,6 +437,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_skip_loop_valid_non_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_SKIP_LOOP; //Create vm @@ -448,6 +456,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_check_access_index_valid() { let hint_code = SQUASH_DICT_INNER_CHECK_ACCESS_INDEX; //Create vm @@ -486,6 +495,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_check_access_current_access_addr_empty() { let hint_code = SQUASH_DICT_INNER_CHECK_ACCESS_INDEX; //Create vm @@ -509,6 +519,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_continue_loop_valid_non_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_CONTINUE_LOOP; //Create vm @@ -527,6 +538,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_continue_loop_valid_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_CONTINUE_LOOP; //Create vm @@ -545,6 +557,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_current_indices_len_is_empty() { let hint_code = SQUASH_DICT_INNER_ASSERT_LEN; //Create vm @@ -560,6 +573,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_current_indices_len_is_empty_not() { let hint_code = SQUASH_DICT_INNER_ASSERT_LEN; //Create vm @@ -575,6 +589,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_valid() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -598,6 +613,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_wrong_used_access_number() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -627,6 +643,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_used_access_number_relocatable() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -652,6 +669,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_empty() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -666,6 +684,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_not_empty() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -680,6 +699,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_no_keys() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -692,6 +712,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_next_key_keys_non_empty() { let hint_code = SQUASH_DICT_INNER_NEXT_KEY; //Create vm @@ -715,6 +736,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_next_key_keys_empty() { let hint_code = SQUASH_DICT_INNER_NEXT_KEY; //Create vm @@ -733,6 +755,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_no_max_size() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -764,13 +787,12 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables + let access_indices_scope_value: HashMap> = + HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]); check_scope!( &exec_scopes, [ - ( - "access_indices", - HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]) - ), + ("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", Felt::one()) ] @@ -780,6 +802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_two_key_dict_no_max_size() { //Dict = {1: (1,1), 1: (1,2), 2: (10,10), 2: (10,20)} let hint_code = SQUASH_DICT; @@ -817,16 +840,14 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables + let access_indices_scope_value: HashMap> = HashMap::from([ + (Felt::one(), vec![Felt::zero(), Felt::one()]), + (Felt::new(2), vec![Felt::new(2), Felt::new(3)]), + ]); check_scope!( &exec_scopes, [ - ( - "access_indices", - HashMap::from([ - (Felt::one(), vec![Felt::zero(), Felt::one()]), - (Felt::new(2), vec![Felt::new(2), Felt::new(3)]) - ]) - ), + ("access_indices", access_indices_scope_value), ("keys", vec![Felt::new(2)]), ("key", Felt::one()) ] @@ -838,6 +859,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_with_max_size() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -870,13 +892,12 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables + let access_indices_scope_value: HashMap> = + HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]); check_scope!( &exec_scopes, [ - ( - "access_indices", - HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]) - ), + ("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", Felt::one()) ] @@ -886,6 +907,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_with_max_size_exceeded() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -926,6 +948,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_bad_ptr_diff() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -960,6 +983,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_with_n_access_too_big() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -1003,6 +1027,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_no_max_size_big_keys() { //Dict = {(prime - 1): (1,1), (prime - 1): (1,2)} let hint_code = SQUASH_DICT; @@ -1046,10 +1071,13 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - check_scope!(&exec_scopes, [("access_indices", HashMap::from([( - felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"), - vec![Felt::zero(), Felt::one()] - )])), ("keys", Vec::::new()), ("key", felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"))]); + let access_indices_scope_value: HashMap> = HashMap::from([( + felt_str!( + "3618502761706184546546682988428055018603476541694452277432519575032261771265" + ), + vec![Felt::zero(), Felt::one()], + )]); + check_scope!(&exec_scopes, [("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"))]); //Check ids variables check_memory![ vm.segments.memory, diff --git a/src/hint_processor/builtin_hint_processor/uint256_utils.rs b/src/hint_processor/builtin_hint_processor/uint256_utils.rs index f358b78713..155a497ec9 100644 --- a/src/hint_processor/builtin_hint_processor/uint256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/uint256_utils.rs @@ -1,3 +1,8 @@ +use crate::stdlib::{ + collections::HashMap, + ops::{Shl, Shr}, + prelude::*, +}; use crate::{ hint_processor::builtin_hint_processor::hint_utils::{ get_integer_from_var_name, get_relocatable_from_var_name, insert_value_from_var_name, @@ -11,10 +16,6 @@ use crate::{ use felt::Felt; use num_integer::div_rem; use num_traits::{One, Signed, Zero}; -use std::{ - collections::HashMap, - ops::{Shl, Shr}, -}; /* Implements hint: %{ @@ -240,9 +241,12 @@ mod tests { }; use assert_matches::assert_matches; use felt::felt_str; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_add_ok() { let hint_code = "sum_low = ids.a.low + ids.b.low\nids.carry_low = 1 if sum_low >= ids.SHIFT else 0\nsum_high = ids.a.high + ids.b.high + ids.carry_low\nids.carry_high = 1 if sum_high >= ids.SHIFT else 0"; let mut vm = vm_with_range_check!(); @@ -264,6 +268,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_add_fail_inserts() { let hint_code = "sum_low = ids.a.low + ids.b.low\nids.carry_low = 1 if sum_low >= ids.SHIFT else 0\nsum_high = ids.a.high + ids.b.high + ids.carry_low\nids.carry_high = 1 if sum_high >= ids.SHIFT else 0"; let mut vm = vm_with_range_check!(); @@ -296,6 +301,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_ok() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -317,6 +323,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_with_big_a() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -339,6 +346,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_memory_error() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -367,6 +375,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_sqrt_ok() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -387,6 +396,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_sqrt_assert_error() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -408,6 +418,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_invalid_memory_insert() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -433,6 +444,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_result_one() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -456,6 +468,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_result_zero() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -479,6 +492,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_invalid_memory_insert() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -503,6 +517,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unsigned_div_rem_ok() { let hint_code = "a = (ids.a.high << 128) + ids.a.low\ndiv = (ids.div.high << 128) + ids.div.low\nquotient, remainder = divmod(a, div)\n\nids.quotient.low = quotient & ((1 << 128) - 1)\nids.quotient.high = quotient >> 128\nids.remainder.low = remainder & ((1 << 128) - 1)\nids.remainder.high = remainder >> 128"; let mut vm = vm_with_range_check!(); @@ -527,6 +542,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unsigned_div_rem_invalid_memory_insert() { let hint_code = "a = (ids.a.high << 128) + ids.a.low\ndiv = (ids.div.high << 128) + ids.div.low\nquotient, remainder = divmod(a, div)\n\nids.quotient.low = quotient & ((1 << 128) - 1)\nids.quotient.high = quotient >> 128\nids.remainder.low = remainder & ((1 << 128) - 1)\nids.remainder.high = remainder >> 128"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/usort.rs b/src/hint_processor/builtin_hint_processor/usort.rs index 72c8b8d6be..f85cbfa3a0 100644 --- a/src/hint_processor/builtin_hint_processor/usort.rs +++ b/src/hint_processor/builtin_hint_processor/usort.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -11,7 +13,6 @@ use crate::{ }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; -use std::{any::Any, collections::HashMap}; pub fn usort_enter_scope(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { if let Ok(usort_max_size) = exec_scopes.get::("usort_max_size") { @@ -99,7 +100,7 @@ pub fn verify_usort( let value = get_integer_from_var_name("value", vm, ids_data, ap_tracking)?.clone(); let mut positions = exec_scopes .get_mut_dict_ref::>("positions_dict")? - .remove(&value) + .remove(value.as_ref()) .ok_or(HintError::UnexpectedPositionsDictFail)?; positions.reverse(); exec_scopes.insert_value("positions", positions); @@ -154,13 +155,18 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn usort_with_max_size() { let mut exec_scopes = scope![("usort_max_size", 1_u64)]; assert_matches!(usort_enter_scope(&mut exec_scopes), Ok(())); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn usort_out_of_range() { let mut vm = vm_with_range_check!(); vm.run_context.fp = 2; diff --git a/src/hint_processor/hint_processor_definition.rs b/src/hint_processor/hint_processor_definition.rs index 8e6bf56a47..5ba8335953 100644 --- a/src/hint_processor/hint_processor_definition.rs +++ b/src/hint_processor/hint_processor_definition.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, boxed::Box, collections::HashMap, prelude::*}; + use crate::any_box; use crate::serde::deserialize_program::ApTracking; use crate::serde::deserialize_program::OffsetValue; @@ -7,8 +9,6 @@ use crate::types::instruction::Register; use crate::vm::errors::hint_errors::HintError; use crate::vm::errors::vm_errors::VirtualMachineError; use crate::vm::vm_core::VirtualMachine; -use std::any::Any; -use std::collections::HashMap; use super::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; use felt::Felt; diff --git a/src/hint_processor/hint_processor_utils.rs b/src/hint_processor/hint_processor_utils.rs index 0a846e8b4a..894e72be5c 100644 --- a/src/hint_processor/hint_processor_utils.rs +++ b/src/hint_processor/hint_processor_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::borrow::Cow; + use crate::{ serde::deserialize_program::{ApTracking, OffsetValue}, types::{ @@ -7,7 +9,6 @@ use crate::{ }, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use std::borrow::Cow; use super::hint_processor_definition::HintReference; use felt::Felt; @@ -177,6 +178,7 @@ fn get_offset_value_reference( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ relocatable, @@ -186,9 +188,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_reference_with_immediate_value() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -204,6 +209,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_offset_value_reference_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -217,6 +223,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_offset_value_reference_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -230,6 +237,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_short_path() { let mut vm = vm!(); vm.segments = segments![((1, 0), (2, 0))]; @@ -245,6 +253,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_with_dereference() { let mut vm = vm!(); vm.segments = segments![((1, 0), (3, 0))]; @@ -260,6 +269,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_with_dereference_and_imm() { let mut vm = vm!(); vm.segments = segments![((1, 0), (4, 0))]; @@ -273,6 +283,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_addr_from_reference_no_regiter_in_reference() { let mut vm = vm!(); vm.segments = segments![((1, 0), (4, 0))]; @@ -283,6 +294,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_addr_from_reference_failed_to_get_ids() { let mut vm = vm!(); vm.segments = segments![((1, 0), 4)]; @@ -297,6 +309,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn tracking_correction_valid() { let mut ref_ap_tracking = ApTracking::new(); ref_ap_tracking.group = 1; @@ -310,6 +323,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn tracking_correction_invalid_group() { let mut ref_ap_tracking = ApTracking::new(); ref_ap_tracking.group = 1; @@ -325,6 +339,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_reference_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -336,6 +351,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_reference_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); diff --git a/src/lib.rs b/src/lib.rs index 6bfda22c3c..021908a50a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,6 +7,52 @@ #![cfg_attr(docsrs, feature(doc_cfg))] #![deny(warnings)] +#![cfg_attr(any(target_arch = "wasm32", not(feature = "std")), no_std)] + +#[cfg(feature = "std")] +include!("./with_std.rs"); +#[cfg(all(not(feature = "std"), feature = "alloc"))] +include!("./with_alloc.rs"); +#[cfg(not(feature = "std"))] +include!("./without_std.rs"); + +mod stdlib { + pub mod collections { + #[cfg(all(not(feature = "std"), feature = "alloc"))] + pub use crate::with_alloc::collections::*; + #[cfg(feature = "std")] + pub use crate::with_std::collections::*; + } + + pub mod borrow { + #[cfg(all(not(feature = "std"), feature = "alloc"))] + pub use crate::with_alloc::borrow::*; + #[cfg(feature = "std")] + pub use crate::with_std::borrow::*; + #[cfg(not(feature = "std"))] + pub use crate::without_std::borrow::*; + } + + pub mod prelude { + pub use crate::stdlib::{ + borrow::ToOwned, + boxed::Box, + clone::Clone, + cmp::{Eq, PartialEq, Reverse}, + iter::IntoIterator, + string::{String, ToString}, + vec::Vec, + }; + } + + #[cfg(all(not(feature = "std"), feature = "alloc"))] + pub use crate::with_alloc::*; + #[cfg(feature = "std")] + pub use crate::with_std::*; + #[cfg(not(feature = "std"))] + pub use crate::without_std::*; +} + pub mod cairo_run; pub mod hint_processor; pub mod math_utils; @@ -14,3 +60,6 @@ pub mod serde; pub mod types; pub mod utils; pub mod vm; + +#[cfg(test)] +mod tests; diff --git a/src/math_utils.rs b/src/math_utils.rs index 70633c449a..0efd4293b5 100644 --- a/src/math_utils.rs +++ b/src/math_utils.rs @@ -1,9 +1,9 @@ +use crate::stdlib::ops::Shr; use crate::types::errors::math_errors::MathError; use felt::Felt; use num_bigint::{BigInt, BigUint}; use num_integer::Integer; use num_traits::{One, Signed, Zero}; -use std::ops::Shr; ///Returns the integer square root of the nonnegative integer n. ///This is the floor of the exact square root of n. @@ -165,7 +165,11 @@ mod tests { use assert_matches::assert_matches; use num_traits::Num; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_a() { let a = bigint_str!( "11260647941622813594563746375280766662237311019551239924981511729608487775604310196863705127454617186486639011517352066501847110680463498585797912894788" @@ -186,6 +190,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_b() { let a = bigint_str!( "29642372811668969595956851264770043260610851505766181624574941701711520154703788233010819515917136995474951116158286220089597404329949295479559895970988" @@ -206,6 +211,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_c() { let a = bigint_str!( "1208267356464811040667664150251401430616174694388968865551115897173431833224432165394286799069453655049199580362994484548890574931604445970825506916876" @@ -226,6 +232,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div() { let x = Felt::new(26); let y = Felt::new(13); @@ -233,6 +240,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_non_divisor() { let x = Felt::new(25); let y = Felt::new(4); @@ -245,6 +253,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_by_zero() { let x = Felt::new(25); let y = Felt::zero(); @@ -253,11 +262,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize() { assert_matches!(safe_div_usize(26, 13), Ok(2)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize_non_divisor() { assert_matches!( safe_div_usize(25, 4), @@ -266,11 +277,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize_by_zero() { assert_matches!(safe_div_usize(25, 0), Err(MathError::DividedByZero)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_line_slope_for_valid_points() { let point_a = ( bigint_str!( @@ -298,6 +311,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_double_slope_for_valid_point_a() { let point = ( bigint_str!( @@ -318,6 +332,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_double_slope_for_valid_point_b() { let point = ( bigint_str!( @@ -338,6 +353,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_a() { let point = ( bigint_str!( @@ -363,6 +379,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_b() { let point = ( bigint_str!( @@ -388,6 +405,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_c() { let point = ( bigint_str!( @@ -413,6 +431,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_a() { let point_a = ( bigint_str!( @@ -445,6 +464,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_b() { let point_a = ( bigint_str!( @@ -477,6 +497,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_c() { let point_a = ( bigint_str!( @@ -509,18 +530,21 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_a() { let n = biguint!(81); assert_matches!(isqrt(&n), Ok(x) if x == biguint!(9)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_b() { let n = biguint_str!("4573659632505831259480"); assert_matches!(isqrt(&n.pow(2_u32)), Ok(num) if num == n); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_c() { let n = biguint_str!( "3618502788666131213697322783095070105623107215331596699973092056135872020481" @@ -529,6 +553,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_zero() { let n = BigUint::zero(); assert_matches!(isqrt(&n), Ok(inner) if inner.is_zero()); diff --git a/src/serde/deserialize_program.rs b/src/serde/deserialize_program.rs index bfe1f6deb6..332964b5ec 100644 --- a/src/serde/deserialize_program.rs +++ b/src/serde/deserialize_program.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, fmt, prelude::*}; + use crate::{ serde::deserialize_utils, types::{ @@ -13,7 +15,6 @@ use felt::{Felt, PRIME_STR}; use num_traits::Num; use serde::{de, de::MapAccess, de::SeqAccess, Deserialize, Deserializer, Serialize}; use serde_json::Number; -use std::{collections::HashMap, fmt, io::Read}; // This enum is used to deserialize program builtins into &str and catch non-valid names #[derive(Deserialize, Debug, PartialEq)] @@ -329,17 +330,22 @@ pub fn deserialize_value_address<'de, D: Deserializer<'de>>( d.deserialize_str(ValueAddressVisitor) } -pub fn deserialize_program_json(reader: impl Read) -> Result { - let program_json = serde_json::from_reader(reader)?; +pub fn deserialize_program_json(reader: &[u8]) -> Result { + let program_json = serde_json::from_slice(reader)?; Ok(program_json) } - -pub fn deserialize_program( - reader: impl Read, +pub fn deserialize_and_parse_program( + reader: &[u8], entrypoint: Option<&str>, ) -> Result { let program_json: ProgramJson = deserialize_program_json(reader)?; + parse_program_json(program_json, entrypoint) +} +pub fn parse_program_json( + program_json: ProgramJson, + entrypoint: Option<&str>, +) -> Result { if PRIME_STR != program_json.prime { return Err(ProgramError::PrimeDiffers(program_json.prime)); } @@ -379,8 +385,8 @@ pub fn deserialize_program( let value = value .value .clone() - .ok_or_else(|| ProgramError::ConstWithoutValue(key.to_owned()))?; - constants.insert(key.to_owned(), value); + .ok_or_else(|| ProgramError::ConstWithoutValue(key.clone()))?; + constants.insert(key.clone(), value); } } @@ -409,9 +415,12 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::Zero; - use std::{fs::File, io::BufReader}; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_from_string_json_gives_error() { let invalid_even_length_hex_json = r#" { @@ -436,6 +445,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_invalid_char_error() { let invalid_char = r#" { @@ -448,6 +458,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_no_prefix_error() { let no_prefix = r#" { @@ -461,6 +472,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_from_string_json() { let valid_json = r#" { @@ -675,12 +687,12 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_a() { // Open json file with (valid) even length encoded hex - let file = File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); - let mut reader = BufReader::new(file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); - let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); + let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); assert_eq!( program_json.prime, @@ -692,12 +704,12 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_b() { // Open json file with (valid) odd length encoded hex - let file = File::open("cairo_programs/manually_compiled/valid_program_b.json").unwrap(); - let mut reader = BufReader::new(file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_b.json"); - let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); + let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); let builtins: Vec = vec![BuiltinName::output, BuiltinName::range_check]; assert_eq!( @@ -710,33 +722,32 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_gives_error() { // Open json file with (invalid) even length encoded hex - let even_length_file = - File::open("cairo_programs/manually_compiled/invalid_even_length_hex.json").unwrap(); - let mut reader = BufReader::new(even_length_file); + let reader = + include_bytes!("../../cairo_programs/manually_compiled/invalid_even_length_hex.json"); - let even_result: Result = serde_json::from_reader(&mut reader); + let even_result: Result = serde_json::from_slice(reader); assert!(even_result.is_err()); // Open json file with (invalid) odd length encoded hex - let odd_length_file = - File::open("cairo_programs/manually_compiled/invalid_odd_length_hex.json").unwrap(); - let mut reader = BufReader::new(odd_length_file); + let reader = + include_bytes!("../../cairo_programs/manually_compiled/invalid_odd_length_hex.json"); - let odd_result: Result = serde_json::from_reader(&mut reader); + let odd_result: Result = serde_json::from_slice(reader); assert!(odd_result.is_err()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_missing_entrypoint_gives_error() { - let even_length_file = - File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); - let reader = BufReader::new(even_length_file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); - let deserialization_result = deserialize_program(reader, Some("missing_function")); + let deserialization_result = + deserialize_and_parse_program(reader, Some("missing_function")); assert!(deserialization_result.is_err()); assert_matches!( deserialization_result, @@ -745,13 +756,12 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_test() { - let even_length_file = - File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); - let reader = BufReader::new(even_length_file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); - let program: Program = - deserialize_program(reader, Some("main")).expect("Failed to deserialize program"); + let program: Program = deserialize_and_parse_program(reader, Some("main")) + .expect("Failed to deserialize program"); let builtins: Vec = Vec::new(); let data: Vec = vec![ @@ -808,13 +818,12 @@ mod tests { /// Deserialize a program without an entrypoint. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_without_entrypoint_test() { - let even_length_file = - File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); - let reader = BufReader::new(even_length_file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); let program: Program = - deserialize_program(reader, None).expect("Failed to deserialize program"); + deserialize_and_parse_program(reader, None).expect("Failed to deserialize program"); let builtins: Vec = Vec::new(); let data: Vec = vec![ @@ -870,12 +879,12 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_constant() { - let file = - File::open("cairo_programs/manually_compiled/deserialize_constant_test.json").unwrap(); - let mut reader = BufReader::new(file); + let reader = + include_bytes!("../../cairo_programs/manually_compiled/deserialize_constant_test.json"); - let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); + let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); let mut identifiers: HashMap = HashMap::new(); identifiers.insert( @@ -964,6 +973,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn value_address_no_hint_reference_default_test() { let valid_json = r#" { @@ -1010,6 +1020,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_attributes_test() { let valid_json = r#" { @@ -1103,6 +1114,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_instruction_locations_test_no_parent() { let valid_json = r#" { @@ -1211,6 +1223,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_instruction_locations_test_with_parent() { let valid_json = r#" { @@ -1311,11 +1324,11 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_with_type_definition() { - let file = File::open("cairo_programs/uint256_integration_tests.json").unwrap(); - let reader = BufReader::new(file); + let reader = include_bytes!("../../cairo_programs/uint256_integration_tests.json"); - let program_json: ProgramJson = serde_json::from_reader(reader).unwrap(); + let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); assert_eq!( program_json.identifiers["starkware.cairo.common.alloc.alloc.Return"] diff --git a/src/serde/deserialize_utils.rs b/src/serde/deserialize_utils.rs index 22225dcdd3..e4c659b901 100644 --- a/src/serde/deserialize_utils.rs +++ b/src/serde/deserialize_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{fmt, num::ParseIntError, prelude::*, str::FromStr}; + use crate::{ serde::deserialize_program::{OffsetValue, ValueAddress}, types::instruction::Register, @@ -17,7 +19,6 @@ use nom::{ }; use num_integer::Integer; use parse_hyperlinks::take_until_unbalanced; -use std::{fmt, num::ParseIntError, str::FromStr}; #[derive(Debug, PartialEq, Eq)] pub enum ReferenceParseError { @@ -174,9 +175,9 @@ pub fn parse_value(input: &str) -> IResult<&str, ValueAddress> { tuple((tag(", "), take_till(|c: char| c == '*')))(second_arg)?; let type_: String = if let Some(indirections) = indirection_level.get(1..) { - struct_.to_owned() + indirections + struct_.to_string() + indirections } else { - struct_.to_owned() + struct_.to_string() }; let fst_offset = fst_offset.unwrap_or(OffsetValue::Value(0)); @@ -214,9 +215,14 @@ pub fn parse_value(input: &str) -> IResult<&str, ValueAddress> { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use num_traits::{One, Zero}; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn outer_brackets_test() { let deref_value = "[cast([fp])]"; let parsed_deref = outer_brackets(deref_value); @@ -228,6 +234,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn take_cast_test() { let value = "cast([fp + (-1)], felt*)"; let parsed = take_cast(value); @@ -235,6 +242,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn take_cast_first_arg_test() { let value = "cast([fp + (-1)] + (-1), felt*)"; let parsed = take_cast_first_arg(value); @@ -243,6 +251,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_register_test() { let value = "fp + (-1)"; let parsed = register(value); @@ -251,6 +260,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_offset_test() { let value_1 = " + (-1)"; let parsed_1 = offset(value_1); @@ -266,6 +276,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_register_and_offset_test() { let value_1 = "fp + 1"; let parsed_1 = register_and_offset(value_1); @@ -279,6 +290,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_inner_dereference_test() { let value = "[fp + (-1)] + 2"; let parsed = inner_dereference(value); @@ -290,6 +302,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_no_inner_dereference_test() { let value = "ap + 3"; let parsed = no_inner_dereference(value); @@ -301,6 +314,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_dereference_test() { let value = "[cast([fp + (-1)] + 2, felt*)]"; let parsed = parse_value(value); @@ -320,6 +334,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_inner_dereference_test() { let value = "cast(ap + 2, felt*)"; let parsed = parse_value(value); @@ -339,6 +354,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_register_test() { let value = "cast(825323, felt*)"; let parsed = parse_value(value); @@ -357,6 +373,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_inner_deref_and_two_offsets() { let value = "[cast(ap - 0 + (-1), felt*)]"; let parsed = parse_value(value); @@ -376,6 +393,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_and_offset2() { let value = "[cast([ap] + 1, __main__.felt*)]"; let parsed = parse_value(value); @@ -395,6 +413,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_and_immediate() { let value = "[cast([ap] + 1, felt)]"; let parsed = parse_value(value); @@ -414,6 +433,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_to_pointer() { let value = "[cast([ap + 1] + 1, felt*)]"; let parsed = parse_value(value); @@ -433,6 +453,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_2_inner_deref() { let value = "[cast([ap] + [fp + 1], __main__.felt*)]"; let parsed = parse_value(value); @@ -452,6 +473,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_2_inner_dereferences() { let value = "[cast([ap + 1] + [fp + 1], __main__.felt*)]"; let parsed = parse_value(value); @@ -471,6 +493,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_reference() { let value = "cast(825323, felt)"; let parsed = parse_value(value); @@ -490,6 +513,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_one_reference() { let value = "[cast([ap] + 1, starkware.cairo.common.cairo_secp.ec.EcPoint*)]"; let parsed = parse_value(value); @@ -509,6 +533,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_doble_reference() { let value = "[cast([ap] + 1, starkware.cairo.common.cairo_secp.ec.EcPoint**)]"; let parsed = parse_value(value); @@ -528,6 +553,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_to_felt_with_doble_reference() { let value = "[cast([ap] + [ap], felt)]"; let parsed = parse_value(value); @@ -547,6 +573,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_to_felt_with_doble_reference_and_offsets() { let value = "[cast([ap + 1] + [ap + 2], felt)]"; let parsed = parse_value(value); diff --git a/tests/bitwise_test.rs b/src/tests/bitwise_test.rs similarity index 94% rename from tests/bitwise_test.rs rename to src/tests/bitwise_test.rs index c2b5cf14d6..7fc819b4fe 100644 --- a/tests/bitwise_test.rs +++ b/src/tests/bitwise_test.rs @@ -1,4 +1,6 @@ -use cairo_vm::{ +use crate::stdlib::prelude::*; + +use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::{ @@ -7,17 +9,19 @@ use cairo_vm::{ }, }; -#[macro_use] -extern crate assert_matches; +use assert_matches::assert_matches; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; -use std::path::Path; #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn bitwise_integration_test() { - let program = Program::from_file( - Path::new("cairo_programs/bitwise_builtin_test.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/bitwise_builtin_test.json"), Some("main"), ) - .expect("Failed to deserialize program"); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); diff --git a/src/tests/cairo_run_test.rs b/src/tests/cairo_run_test.rs new file mode 100644 index 0000000000..8930d3c7aa --- /dev/null +++ b/src/tests/cairo_run_test.rs @@ -0,0 +1,1402 @@ +use crate::stdlib::prelude::*; + +use crate::cairo_run::{self, CairoRunConfig}; +use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn fibonacci() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/fibonacci.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn array_sum() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/array_sum.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn big_struct() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/big_struct.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn call_function_assign_param_by_name() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/call_function_assign_param_by_name.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn function_return() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/function_return.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn function_return_if_print() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/function_return_if_print.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn function_return_to_variable() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/function_return_to_variable.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn if_and_prime() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/if_and_prime.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn if_in_function() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/if_in_function.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn if_list() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/if_list.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn jmp() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/jmp.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn jmp_if_condition() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/jmp_if_condition.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn pointers() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/pointers.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn print() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/print.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn program_return() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/return.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn reversed_register_instructions() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/reversed_register_instructions.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn simple_print() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/simple_print.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn test_addition_if() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/test_addition_if.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn test_reverse_if() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/test_reverse_if.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn test_subtraction_if() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/test_subtraction_if.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn use_imported_module() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/use_imported_module.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bitwise_output() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bitwise_output.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bitwise_recursion() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bitwise_recursion.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn integration() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/integration.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn integration_with_alloc_locals() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/integration_with_alloc_locals.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn compare_arrays() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/compare_arrays.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn compare_greater_array() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/compare_greater_array.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn compare_lesser_array() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/compare_lesser_array.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_le_felt_hint() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_le_felt_hint.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_250_bit_element_array() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_250_bit_element_array.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn abs_value_array() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/abs_value_array.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn compare_different_arrays() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/compare_different_arrays.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_nn() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_nn.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn sqrt() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/sqrt.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_not_zero() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_not_zero.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn split_int() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/split_int.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn split_int_big() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/split_int_big.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn split_felt() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/split_felt.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn math_cmp() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/math_cmp.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn unsigned_div_rem() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/unsigned_div_rem.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn signed_div_rem() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/signed_div_rem.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_lt_felt() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_lt_felt.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn memcpy_test() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/memcpy_test.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn memset() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/memset.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn pow() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/pow.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict_update() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict_update.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn uint256() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/uint256.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn find_element() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/find_element.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn search_sorted_lower() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/search_sorted_lower.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn usort() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/usort.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn squash_dict() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/squash_dict.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict_squash() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict_squash.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn set_add() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/set_add.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn secp() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/secp.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn signature() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/signature.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn secp_ec() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/secp_ec.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn blake2s_hello_world_hash() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/blake2s_hello_world_hash.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn finalize_blake2s() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/finalize_blake2s.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn unsafe_keccak() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/unsafe_keccak.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn blake2s_felts() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/blake2s_felts.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn unsafe_keccak_finalize() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/unsafe_keccak_finalize.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn keccak_add_uint256() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/keccak_add_uint256.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn keccak() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/_keccak.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn keccak_copy_inputs() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/keccak_copy_inputs.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn cairo_finalize_keccak() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/cairo_finalize_keccak.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn operations_with_data_structures() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/operations_with_data_structures.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn sha256() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/sha256.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn math_cmp_and_pow_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/math_cmp_and_pow_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn uint256_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/uint256_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn set_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/set_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn memory_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/memory_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn secp_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/secp_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn keccak_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/keccak_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn blake2s_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/blake2s_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn relocate_segments() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/relocate_segments.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict_store_cast_ptr() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict_store_cast_ptr.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn common_signature() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/common_signature.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bad_usort() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/bad_usort.json"); + let expected_error_message = "unexpected verify multiplicity fail: positions length != 0"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bad_dict_new() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/bad_dict_new.json"); + let expected_error_message = "Dict Error: Tried to create a dict whithout an initial dict"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bad_dict_update() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/bad_dict_update.json"); + let expected_error_message = + "Dict Error: Got the wrong value for dict_update, expected value: 3, got: 5 for key: 2"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn error_msg_attr() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr.json"); + let expected_error_message = "SafeUint256: addition overflow"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn error_msg_attr_tempvar() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"); + + #[cfg(feature = "std")] + let expected_error_message = "Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n assert x = 2;\n ^***********^\n"; + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_error_message = "Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn error_msg_attr_struct() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr_struct.json"); + let expected_error_message = "Error message: Cats cannot have more than nine lives: {cat} (Cannot evaluate ap-based or complex references: ['cat'])"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} diff --git a/tests/compare_vm_state.sh b/src/tests/compare_vm_state.sh similarity index 100% rename from tests/compare_vm_state.sh rename to src/tests/compare_vm_state.sh diff --git a/tests/memory_comparator.py b/src/tests/memory_comparator.py similarity index 100% rename from tests/memory_comparator.py rename to src/tests/memory_comparator.py diff --git a/src/tests/mod.rs b/src/tests/mod.rs new file mode 100644 index 0000000000..47c3be4d51 --- /dev/null +++ b/src/tests/mod.rs @@ -0,0 +1,7 @@ +mod bitwise_test; +mod cairo_run_test; +mod pedersen_test; +mod struct_test; + +#[cfg(feature = "skip_next_instruction_hint")] +mod skip_instruction_test; diff --git a/tests/pedersen_test.rs b/src/tests/pedersen_test.rs similarity index 87% rename from tests/pedersen_test.rs rename to src/tests/pedersen_test.rs index 0392243d69..bc21549338 100644 --- a/tests/pedersen_test.rs +++ b/src/tests/pedersen_test.rs @@ -1,17 +1,25 @@ -use std::path::Path; -#[macro_use] -extern crate assert_matches; -use cairo_vm::{ +use crate::stdlib::prelude::*; + +use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::trace::trace_entry::RelocatedTraceEntry, vm::{runners::cairo_runner::CairoRunner, vm_core::VirtualMachine}, }; +use assert_matches::assert_matches; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; + #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn pedersen_integration_test() { - let program = Program::from_file(Path::new("cairo_programs/pedersen_test.json"), Some("main")) - .expect("Failed to deserialize program"); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/pedersen_test.json"), + Some("main"), + ) + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); diff --git a/tests/skip_instruction_test.rs b/src/tests/skip_instruction_test.rs similarity index 61% rename from tests/skip_instruction_test.rs rename to src/tests/skip_instruction_test.rs index c8675e58a5..d781c8faac 100644 --- a/tests/skip_instruction_test.rs +++ b/src/tests/skip_instruction_test.rs @@ -1,23 +1,24 @@ -#[cfg(feature = "skip_next_instruction_hint")] -use cairo_vm::{ +use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::{runners::cairo_runner::CairoRunner, vm_core::VirtualMachine}, }; -#[macro_use] -extern crate assert_matches; -#[cfg(feature = "skip_next_instruction_hint")] -use std::path::Path; +use assert_matches::assert_matches; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; -#[cfg(feature = "skip_next_instruction_hint")] #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn skip_next_instruction_test() { - let program = Program::from_file( - Path::new("cairo_programs/noretrocompat/test_skip_next_instruction.noretrocompat.json"), + let program = Program::from_bytes( + include_bytes!( + "../../cairo_programs/noretrocompat/test_skip_next_instruction.noretrocompat.json" + ), Some("main"), ) - .expect("Failed to deserialize program"); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); diff --git a/tests/struct_test.rs b/src/tests/struct_test.rs similarity index 63% rename from tests/struct_test.rs rename to src/tests/struct_test.rs index cd443c051f..72b7f65d86 100644 --- a/tests/struct_test.rs +++ b/src/tests/struct_test.rs @@ -1,21 +1,23 @@ -use cairo_vm::{ +use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, - vm::vm_core::VirtualMachine, + types::program::Program, vm::vm_core::VirtualMachine, }; -use std::path::Path; -use cairo_vm::{ - types::program::Program, - vm::{runners::cairo_runner::CairoRunner, trace::trace_entry::RelocatedTraceEntry}, -}; +use crate::vm::{runners::cairo_runner::CairoRunner, trace::trace_entry::RelocatedTraceEntry}; + +use assert_matches::assert_matches; -#[macro_use] -extern crate assert_matches; +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn struct_integration_test() { - let program = Program::from_file(Path::new("cairo_programs/struct.json"), Some("main")) - .expect("Failed to deserialize program"); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/struct.json"), + Some("main"), + ) + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); diff --git a/src/types/errors/math_errors.rs b/src/types/errors/math_errors.rs index bb7accb49a..9350e0eb74 100644 --- a/src/types/errors/math_errors.rs +++ b/src/types/errors/math_errors.rs @@ -1,6 +1,10 @@ use felt::Felt; use num_bigint::{BigInt, BigUint}; + +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; diff --git a/src/types/errors/program_errors.rs b/src/types/errors/program_errors.rs index c74d7456d3..9a8437e7d5 100644 --- a/src/types/errors/program_errors.rs +++ b/src/types/errors/program_errors.rs @@ -1,11 +1,17 @@ -use felt::PRIME_STR; -use std::io; +use crate::stdlib::prelude::*; + +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + +use felt::PRIME_STR; #[derive(Debug, Error)] pub enum ProgramError { + #[cfg(feature = "std")] #[error(transparent)] - IO(#[from] io::Error), + IO(#[from] std::io::Error), #[error(transparent)] Parse(#[from] serde_json::Error), #[error("Entrypoint {0} not found")] @@ -20,7 +26,11 @@ pub enum ProgramError { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn format_entrypoint_not_found_error() { let error = ProgramError::EntrypointNotFound(String::from("my_function")); let formatted_error = format!("{error}"); diff --git a/src/types/exec_scope.rs b/src/types/exec_scope.rs index 1721d02f17..941525e26b 100644 --- a/src/types/exec_scope.rs +++ b/src/types/exec_scope.rs @@ -1,10 +1,11 @@ +use crate::stdlib::{any::Any, cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; use crate::{ any_box, hint_processor::builtin_hint_processor::dict_manager::DictManager, vm::errors::{exec_scope_errors::ExecScopeError, hint_errors::HintError}, }; -use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; +#[derive(Debug)] pub struct ExecutionScopes { pub data: Vec>>, } @@ -190,13 +191,18 @@ mod tests { use felt::Felt; use num_traits::One; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_execution_scopes() { let scopes = ExecutionScopes::new(); assert_eq!(scopes.data.len(), 1); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_local_variables_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -217,6 +223,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn enter_new_scope_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2_i32)); @@ -259,6 +266,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -295,6 +303,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assign_local_variable_test() { let var_value: Box = Box::new(Felt::new(2)); @@ -315,6 +324,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn re_assign_local_variable_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -340,6 +350,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn delete_local_variable_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -362,6 +373,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_main_scope_gives_error_test() { let mut scopes = ExecutionScopes::new(); @@ -369,6 +381,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_listu64_test() { let list_u64: Box = Box::new(vec![20_u64, 18_u64]); @@ -390,6 +403,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_u64_test() { let u64: Box = Box::new(9_u64); @@ -415,6 +429,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_mut_int_ref_test() { let bigint: Box = Box::new(Felt::new(12)); @@ -428,6 +443,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_any_boxed_test() { let list_u64: Box = Box::new(vec![20_u64, 18_u64]); diff --git a/src/types/instance_definitions/bitwise_instance_def.rs b/src/types/instance_definitions/bitwise_instance_def.rs index 0f1a6c5b04..8cea97d21b 100644 --- a/src/types/instance_definitions/bitwise_instance_def.rs +++ b/src/types/instance_definitions/bitwise_instance_def.rs @@ -35,19 +35,25 @@ impl BitwiseInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = BitwiseInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = BitwiseInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 5); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = BitwiseInstanceDef { ratio: 8, @@ -57,6 +63,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = BitwiseInstanceDef { ratio: 256, diff --git a/src/types/instance_definitions/builtins_instance_def.rs b/src/types/instance_definitions/builtins_instance_def.rs index c29ee400b2..95be8bb98f 100644 --- a/src/types/instance_definitions/builtins_instance_def.rs +++ b/src/types/instance_definitions/builtins_instance_def.rs @@ -105,7 +105,11 @@ impl BuiltinsInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_plain() { let builtins = BuiltinsInstanceDef::plain(); assert!(!builtins.output); @@ -117,6 +121,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_small() { let builtins = BuiltinsInstanceDef::small(); assert!(builtins.output); @@ -128,6 +133,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_dex() { let builtins = BuiltinsInstanceDef::dex(); assert!(builtins.output); @@ -139,6 +145,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_perpetual_with_bitwise() { let builtins = BuiltinsInstanceDef::perpetual_with_bitwise(); assert!(builtins.output); @@ -150,6 +157,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_bitwise() { let builtins = BuiltinsInstanceDef::bitwise(); assert!(builtins.output); @@ -161,6 +169,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_recursive() { let builtins = BuiltinsInstanceDef::recursive(); assert!(builtins.output); @@ -172,6 +181,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_all() { let builtins = BuiltinsInstanceDef::all(); assert!(builtins.output); diff --git a/src/types/instance_definitions/cpu_instance_def.rs b/src/types/instance_definitions/cpu_instance_def.rs index 7aa89b2e17..0bee2496ea 100644 --- a/src/types/instance_definitions/cpu_instance_def.rs +++ b/src/types/instance_definitions/cpu_instance_def.rs @@ -13,7 +13,11 @@ impl CpuInstanceDef { mod tests { use super::CpuInstanceDef; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let cpu_instance = CpuInstanceDef::default(); assert!(cpu_instance._safe_call) diff --git a/src/types/instance_definitions/diluted_pool_instance_def.rs b/src/types/instance_definitions/diluted_pool_instance_def.rs index 7a7f756c45..8138c573bd 100644 --- a/src/types/instance_definitions/diluted_pool_instance_def.rs +++ b/src/types/instance_definitions/diluted_pool_instance_def.rs @@ -27,7 +27,11 @@ impl DilutedPoolInstanceDef { mod tests { use super::DilutedPoolInstanceDef; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let diluted_pool = DilutedPoolInstanceDef::default(); assert_eq!(diluted_pool.units_per_step, 16); @@ -36,6 +40,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let diluted_pool = DilutedPoolInstanceDef::new(1, 1, 1); assert_eq!(diluted_pool.units_per_step, 1); diff --git a/src/types/instance_definitions/ec_op_instance_def.rs b/src/types/instance_definitions/ec_op_instance_def.rs index 03083c6866..f777589842 100644 --- a/src/types/instance_definitions/ec_op_instance_def.rs +++ b/src/types/instance_definitions/ec_op_instance_def.rs @@ -38,19 +38,25 @@ impl EcOpInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = EcOpInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = EcOpInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 7); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = EcOpInstanceDef { ratio: 8, @@ -61,6 +67,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = EcOpInstanceDef { ratio: 256, diff --git a/src/types/instance_definitions/ecdsa_instance_def.rs b/src/types/instance_definitions/ecdsa_instance_def.rs index fdd48c1d3f..689443f682 100644 --- a/src/types/instance_definitions/ecdsa_instance_def.rs +++ b/src/types/instance_definitions/ecdsa_instance_def.rs @@ -41,19 +41,25 @@ impl EcdsaInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = EcdsaInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = EcdsaInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 2); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = EcdsaInstanceDef { ratio: 8, @@ -65,6 +71,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = EcdsaInstanceDef { ratio: 512, diff --git a/src/types/instance_definitions/keccak_instance_def.rs b/src/types/instance_definitions/keccak_instance_def.rs index d1bf77195e..d01c666622 100644 --- a/src/types/instance_definitions/keccak_instance_def.rs +++ b/src/types/instance_definitions/keccak_instance_def.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + #[derive(Clone, Debug, PartialEq)] pub(crate) struct KeccakInstanceDef { pub(crate) _ratio: u32, @@ -38,19 +40,25 @@ impl KeccakInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = KeccakInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = KeccakInstanceDef::default(); assert_eq!(builtin_instance.cells_per_builtin(), 16); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = KeccakInstanceDef { _ratio: 2048, @@ -61,6 +69,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = KeccakInstanceDef { _ratio: 2048, diff --git a/src/types/instance_definitions/pedersen_instance_def.rs b/src/types/instance_definitions/pedersen_instance_def.rs index bd225d059c..dad14cdebb 100644 --- a/src/types/instance_definitions/pedersen_instance_def.rs +++ b/src/types/instance_definitions/pedersen_instance_def.rs @@ -49,19 +49,25 @@ impl PedersenInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = PedersenInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = PedersenInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 3); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = PedersenInstanceDef { ratio: 10, @@ -75,6 +81,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = PedersenInstanceDef { ratio: 8, diff --git a/src/types/instance_definitions/range_check_instance_def.rs b/src/types/instance_definitions/range_check_instance_def.rs index 24057a7888..bc67866e8a 100644 --- a/src/types/instance_definitions/range_check_instance_def.rs +++ b/src/types/instance_definitions/range_check_instance_def.rs @@ -31,19 +31,25 @@ impl RangeCheckInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = RangeCheckInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 8); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = RangeCheckInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 1); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = RangeCheckInstanceDef { ratio: 10, @@ -53,6 +59,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = RangeCheckInstanceDef { ratio: 8, diff --git a/src/types/instruction.rs b/src/types/instruction.rs index f6f7590d23..d3d43866e9 100644 --- a/src/types/instruction.rs +++ b/src/types/instruction.rs @@ -103,7 +103,11 @@ pub(crate) fn is_call_instruction(encoded_instruction: &Felt, imm: Option<&Felt> mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_call_instruction_true() { let encoded_instruction = Felt::new(1226245742482522112_i64); assert!(is_call_instruction( @@ -112,12 +116,14 @@ mod tests { )); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_call_instruction_false() { let encoded_instruction = Felt::new(4612671187288031229_i64); assert!(!is_call_instruction(&encoded_instruction, None)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn instruction_size() { let encoded_instruction = Felt::new(1226245742482522112_i64); let instruction = diff --git a/src/types/layout.rs b/src/types/layout.rs index 1e37c654a5..3d9e7cebab 100644 --- a/src/types/layout.rs +++ b/src/types/layout.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use super::instance_definitions::{ builtins_instance_def::BuiltinsInstanceDef, cpu_instance_def::CpuInstanceDef, diluted_pool_instance_def::DilutedPoolInstanceDef, @@ -120,7 +122,11 @@ impl CairoLayout { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_plain_instance() { let layout = CairoLayout::plain_instance(); let builtins = BuiltinsInstanceDef::plain(); @@ -136,6 +142,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_small_instance() { let layout = CairoLayout::small_instance(); let builtins = BuiltinsInstanceDef::small(); @@ -151,6 +158,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_dex_instance() { let layout = CairoLayout::dex_instance(); let builtins = BuiltinsInstanceDef::dex(); @@ -166,6 +174,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perpetual_with_bitwise_instance() { let layout = CairoLayout::perpetual_with_bitwise_instance(); let builtins = BuiltinsInstanceDef::perpetual_with_bitwise(); @@ -184,6 +193,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_bitwise_instance() { let layout = CairoLayout::bitwise_instance(); let builtins = BuiltinsInstanceDef::bitwise(); @@ -202,6 +212,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_recursive_instance() { let layout = CairoLayout::recursive_instance(); let builtins = BuiltinsInstanceDef::recursive(); @@ -220,6 +231,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_all_instance() { let layout = CairoLayout::all_instance(); let builtins = BuiltinsInstanceDef::all(); diff --git a/src/types/program.rs b/src/types/program.rs index 36cbc9ad8a..d27fc3b31e 100644 --- a/src/types/program.rs +++ b/src/types/program.rs @@ -1,17 +1,17 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ serde::deserialize_program::{ - deserialize_program, Attribute, HintParams, Identifier, InstructionLocation, + deserialize_and_parse_program, Attribute, HintParams, Identifier, InstructionLocation, ReferenceManager, }, types::{errors::program_errors::ProgramError, relocatable::MaybeRelocatable}, }; use felt::{Felt, PRIME_STR}; use serde::Serialize; -use std::{ - fs::File, - io::{BufReader, Read}, - {collections::HashMap, path::Path}, -}; + +#[cfg(feature = "std")] +use std::path::Path; #[derive(Clone, Debug, PartialEq, Eq, Serialize)] pub struct Program { @@ -54,8 +54,8 @@ impl Program { let value = value .value .clone() - .ok_or_else(|| ProgramError::ConstWithoutValue(key.to_owned()))?; - constants.insert(key.to_owned(), value); + .ok_or_else(|| ProgramError::ConstWithoutValue(key.clone()))?; + constants.insert(key.clone(), value); } } @@ -72,18 +72,14 @@ impl Program { }) } + #[cfg(feature = "std")] pub fn from_file(path: &Path, entrypoint: Option<&str>) -> Result { - let file = File::open(path)?; - let reader = BufReader::new(file); - - deserialize_program(reader, entrypoint) + let file_content = std::fs::read(path)?; + deserialize_and_parse_program(&file_content, entrypoint) } - pub fn from_reader( - reader: impl Read, - entrypoint: Option<&str>, - ) -> Result { - deserialize_program(reader, entrypoint) + pub fn from_bytes(bytes: &[u8], entrypoint: Option<&str>) -> Result { + deserialize_and_parse_program(bytes, entrypoint) } } @@ -111,11 +107,15 @@ impl Default for Program { mod tests { use super::*; use crate::serde::deserialize_program::{ApTracking, FlowTrackingData}; - use crate::utils::test_utils::mayberelocatable; + use crate::utils::test_utils::*; use felt::felt_str; use num_traits::Zero; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -151,6 +151,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new_program_with_identifiers() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -220,6 +221,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new_program_with_invalid_identifiers() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -278,12 +280,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_test() { - let program: Program = Program::from_file( - Path::new("cairo_programs/manually_compiled/valid_program_a.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"), Some("main"), ) - .expect("Failed to deserialize program"); + .unwrap(); let builtins: Vec<&'static str> = Vec::new(); let data: Vec = vec![ @@ -362,12 +365,13 @@ mod tests { /// Deserialize a program without an entrypoint. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_without_entrypoint_test() { - let program: Program = Program::from_file( - Path::new("cairo_programs/manually_compiled/valid_program_a.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"), None, ) - .expect("Failed to deserialize program"); + .unwrap(); let builtins: Vec<&'static str> = Vec::new(); @@ -461,12 +465,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_constants_test() { - let program = Program::from_file( - Path::new("cairo_programs/manually_compiled/deserialize_constant_test.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/manually_compiled/deserialize_constant_test.json"), Some("main"), ) - .expect("Failed to deserialize program"); + .unwrap(); let constants = [ ("__main__.compare_abs_arrays.SIZEOF_LOCALS", Felt::zero()), @@ -499,6 +504,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn default_program() { let program = Program { builtins: Vec::new(), diff --git a/src/types/relocatable.rs b/src/types/relocatable.rs index 2b3bae84fc..36719ab182 100644 --- a/src/types/relocatable.rs +++ b/src/types/relocatable.rs @@ -1,13 +1,15 @@ +use crate::stdlib::{ + fmt::{self, Display}, + ops::{Add, AddAssign, Sub}, + prelude::*, +}; + use crate::{ relocatable, types::errors::math_errors::MathError, vm::errors::memory_errors::MemoryError, }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; use serde::{Deserialize, Serialize}; -use std::{ - fmt::{self, Display}, - ops::{Add, AddAssign, Sub}, -}; #[derive(Eq, Hash, PartialEq, PartialOrd, Clone, Copy, Debug, Serialize, Deserialize)] pub struct Relocatable { @@ -354,7 +356,11 @@ mod tests { use felt::felt_str; use num_traits::{One, Zero}; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_int() { let addr = MaybeRelocatable::from(Felt::new(7i32)); let added_addr = addr.add_int(&Felt::new(2i32)); @@ -362,6 +368,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_usize_to_int() { let addr = MaybeRelocatable::from(Felt::new(7_i32)); let added_addr = addr.add_usize(2).unwrap(); @@ -369,6 +376,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_relocatable() { let addr = MaybeRelocatable::RelocatableValue(relocatable!(7, 65)); let added_addr = addr.add_int(&Felt::new(2)); @@ -382,6 +390,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_mod_offset_exceeded() { let addr = MaybeRelocatable::from((0, 0)); let error = addr.add_int(&felt_str!("18446744073709551616")); @@ -395,6 +404,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_usize_to_relocatable() { let addr = MaybeRelocatable::RelocatableValue(relocatable!(7, 65)); let added_addr = addr.add_usize(2); @@ -408,6 +418,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_int_prime_mod() { let addr = MaybeRelocatable::Int(felt_str!( "800000000000011000000000000000000000000000000000000000000000004", @@ -418,6 +429,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_relocatable_prime() { let addr = MaybeRelocatable::from((1, 9)); let added_addr = addr.add_int(&felt_str!( @@ -433,6 +445,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_int() { let addr_a = &MaybeRelocatable::from(felt_str!( "3618502788666131213697322783095070105623107215331596699973092056135872020488" @@ -443,6 +456,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocatable_to_relocatable_should_fail() { let addr_a = &MaybeRelocatable::from((7, 5)); let addr_b = &MaybeRelocatable::RelocatableValue(relocatable!(7, 10)); @@ -457,6 +471,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_relocatable() { let addr_a = &MaybeRelocatable::from((7, 7)); let addr_b = &MaybeRelocatable::from(Felt::new(10)); @@ -471,6 +486,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocatable_to_int() { let addr_a = &MaybeRelocatable::from(Felt::new(10_i32)); let addr_b = &MaybeRelocatable::RelocatableValue(relocatable!(7, 7)); @@ -485,6 +501,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_relocatable_prime() { let addr_a = &MaybeRelocatable::from((7, 14)); let addr_b = &MaybeRelocatable::Int(felt_str!( @@ -502,6 +519,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_rel_int_offset_exceeded() { let addr = MaybeRelocatable::from((0, 0)); let error = addr.add(&MaybeRelocatable::from(felt_str!("18446744073709551616"))); @@ -515,6 +533,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_int_rel_offset_exceeded() { let addr = MaybeRelocatable::Int(felt_str!("18446744073709551616")); let relocatable = Relocatable { @@ -532,6 +551,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_int_from_int() { let addr_a = &MaybeRelocatable::from(Felt::new(7)); let addr_b = &MaybeRelocatable::from(Felt::new(5)); @@ -540,6 +560,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_relocatable_from_relocatable_same_offset() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from((7, 7)); @@ -548,6 +569,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_relocatable_from_relocatable_diff_offset() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from((8, 7)); @@ -562,6 +584,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_int_addr_ref_from_relocatable_addr_ref() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from(Felt::new(5_i32)); @@ -570,6 +593,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_rel_to_int_error() { assert_eq!( MaybeRelocatable::from(Felt::new(7_i32)).sub(&MaybeRelocatable::from((7, 10))), @@ -581,6 +605,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn divmod_working() { let value = &MaybeRelocatable::from(Felt::new(10)); let div = &MaybeRelocatable::from(Felt::new(3)); @@ -590,6 +615,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn divmod_bad_type() { let value = &MaybeRelocatable::from(Felt::new(10)); let div = &MaybeRelocatable::from((2, 7)); @@ -603,6 +629,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value() { let value = MaybeRelocatable::from((2, 7)); let relocation_table = vec![1, 2, 5]; @@ -610,6 +637,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -620,6 +648,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value_with_offset() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -630,6 +659,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value_error() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -640,6 +670,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_int_value() { let value = MaybeRelocatable::from(Felt::new(7)); let relocation_table = vec![1, 2, 5]; @@ -647,6 +678,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value_no_relocation() { let value = MaybeRelocatable::from((2, 7)); let relocation_table = vec![1, 2]; @@ -657,12 +689,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_int() { assert_eq!(relocatable!(1, 2) + &Felt::new(4), Ok(relocatable!(1, 6))); assert_eq!(relocatable!(3, 2) + &Felt::zero(), Ok(relocatable!(3, 2))); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_int_mod_offset_exceeded_error() { assert_eq!( relocatable!(0, 0) + &(Felt::new(usize::MAX) + 1_usize), @@ -674,6 +708,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_i32() { let reloc = relocatable!(1, 5); @@ -692,6 +727,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mayberelocatable_try_into_reloctable() { let address = mayberelocatable!(1, 2); assert_eq!(Ok(relocatable!(1, 2)), address.try_into()); @@ -702,6 +738,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_sub_rel_test() { let reloc = relocatable!(7, 6); assert_eq!(reloc - relocatable!(7, 5), Ok(1)); @@ -712,6 +749,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_rel_different_indexes() { let a = relocatable!(7, 6); let b = relocatable!(8, 6); @@ -719,6 +757,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_ok() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(2), @@ -743,6 +782,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_add_two_relocatable_error() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(1, 2), @@ -754,6 +794,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_offset_exceeded_error() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(usize::MAX as i128 + 1), @@ -765,6 +806,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_test() { assert_eq!( mayberelocatable!(1, 2).get_relocatable(), @@ -774,6 +816,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_display() { assert_eq!( format!("{}", Relocatable::from((1, 0))), @@ -782,6 +825,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn maybe_relocatable_relocatable_display() { assert_eq!( format!("{}", MaybeRelocatable::from((1, 0))), @@ -790,6 +834,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn maybe_relocatable_int_display() { assert_eq!( format!("{}", MaybeRelocatable::from(Felt::new(6))), diff --git a/src/utils.rs b/src/utils.rs index 8e9db41827..82721de83f 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use crate::types::relocatable::Relocatable; use felt::Felt; use lazy_static::lazy_static; @@ -20,7 +22,7 @@ lazy_static! { #[macro_export] macro_rules! any_box { ($val : expr) => { - Box::new($val) as Box + $crate::stdlib::boxed::Box::new($val) as $crate::stdlib::boxed::Box }; } @@ -144,9 +146,9 @@ pub mod test_utils { let mut res = $mem.insert(k, v); while matches!(res, Err(MemoryError::UnallocatedSegment(_, _))) { if $si < 0 { - $mem.temp_data.push(Vec::new()) + $mem.temp_data.push($crate::stdlib::vec::Vec::new()) } else { - $mem.data.push(Vec::new()); + $mem.data.push($crate::stdlib::vec::Vec::new()); } res = $mem.insert(k, v); } @@ -156,9 +158,9 @@ pub mod test_utils { let mut res = $mem.insert(k, v); while matches!(res, Err(MemoryError::UnallocatedSegment(_, _))) { if $si < 0 { - $mem.temp_data.push(Vec::new()) + $mem.temp_data.push($crate::stdlib::vec::Vec::new()) } else { - $mem.data.push(Vec::new()); + $mem.data.push($crate::stdlib::vec::Vec::new()); } res = $mem.insert(k, v); } @@ -203,7 +205,7 @@ pub mod test_utils { macro_rules! references { ($num: expr) => {{ - let mut references = HashMap::::new(); + let mut references = crate::stdlib::collections::HashMap::::new(); for i in 0..$num { references.insert(i as usize, HintReference::new_simple((i as i32 - $num))); } @@ -250,17 +252,17 @@ pub mod test_utils { Program { builtins: vec![$( $builtin_name ),*], prime: "0x800000000000011000000000000000000000000000000000000000000000001".to_string(), - data: Vec::new(), - constants: HashMap::new(), + data: crate::stdlib::vec::Vec::new(), + constants: crate::stdlib::collections::HashMap::new(), main: None, start: None, end: None, - hints: HashMap::new(), + hints: crate::stdlib::collections::HashMap::new(), reference_manager: ReferenceManager { - references: Vec::new(), + references: crate::stdlib::vec::Vec::new(), }, - identifiers: HashMap::new(), - error_message_attributes: Vec::new(), + identifiers: crate::stdlib::collections::HashMap::new(), + error_message_attributes: crate::stdlib::vec::Vec::new(), instruction_locations: None, } }; @@ -301,9 +303,9 @@ pub mod test_utils { { let ids_names = vec![$( $name ),*]; let references = references!(ids_names.len() as i32); - let mut ids_data = HashMap::::new(); + let mut ids_data = crate::stdlib::collections::HashMap::::new(); for (i, name) in ids_names.iter().enumerate() { - ids_data.insert(name.to_string(), references.get(&i).unwrap().clone()); + ids_data.insert(crate::stdlib::string::ToString::to_string(name), references.get(&i).unwrap().clone()); } ids_data } @@ -314,9 +316,9 @@ pub mod test_utils { macro_rules! non_continuous_ids_data { ( $( ($name: expr, $offset:expr) ),* ) => { { - let mut ids_data = HashMap::::new(); + let mut ids_data = crate::stdlib::collections::HashMap::::new(); $( - ids_data.insert(String::from($name), HintReference::new_simple($offset)); + ids_data.insert(crate::stdlib::string::String::from($name), HintReference::new_simple($offset)); )* ids_data } @@ -365,23 +367,29 @@ pub mod test_utils { hint_processor.execute_hint(&mut $vm, $exec_scopes, &any_box!(hint_data), $constants) }}; ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr) => {{ - let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); + let hint_data = HintProcessorData::new_default( + crate::stdlib::string::ToString::to_string($hint_code), + $ids_data, + ); let mut hint_processor = BuiltinHintProcessor::new_empty(); hint_processor.execute_hint( &mut $vm, $exec_scopes, &any_box!(hint_data), - &HashMap::new(), + &crate::stdlib::collections::HashMap::new(), ) }}; ($vm:expr, $ids_data:expr, $hint_code:expr) => {{ - let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); + let hint_data = HintProcessorData::new_default( + crate::stdlib::string::ToString::to_string($hint_code), + $ids_data, + ); let mut hint_processor = BuiltinHintProcessor::new_empty(); hint_processor.execute_hint( &mut $vm, exec_scopes_ref!(), &any_box!(hint_data), - &HashMap::new(), + &crate::stdlib::collections::HashMap::new(), ) }}; } @@ -465,13 +473,13 @@ pub mod test_utils { )* let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) }; ($exec_scopes:expr, $tracker_num:expr) => { let tracker = DictTracker::new_empty(relocatable!($tracker_num, 0)); let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) }; } @@ -485,13 +493,13 @@ pub mod test_utils { )* let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) }; ($exec_scopes:expr, $tracker_num:expr,$default:expr) => { let tracker = DictTracker::new_default_dict(relocatable!($tracker_num, 0), &MaybeRelocatable::from($default), None); let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) }; } pub(crate) use dict_manager_default; @@ -513,7 +521,7 @@ pub mod test_utils { } pub(crate) use vec_data_inner; - pub fn check_scope_value( + pub fn check_scope_value( scopes: &ExecutionScopes, name: &str, value: T, @@ -525,6 +533,7 @@ pub mod test_utils { #[cfg(test)] mod test { + use crate::stdlib::{cell::RefCell, collections::HashMap, rc::Rc, string::String, vec::Vec}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -543,11 +552,14 @@ mod test { }; use felt::Felt; use num_traits::One; - use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; use super::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memory_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -570,6 +582,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -593,6 +606,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_address_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -617,6 +631,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_run_context() { let mut vm = vm!(); run_context!(vm, 2, 6, 10); @@ -627,6 +642,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_trace() { let trace = vec![ TraceEntry { @@ -683,6 +699,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_non_continuous_ids_data() { let ids_data_macro = non_continuous_ids_data![("a", -2), ("", -6)]; let ids_data_verbose = HashMap::from([ @@ -693,6 +710,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_hint_alloc() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -703,6 +721,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_scope_test_pass() { let mut exec_scopes = ExecutionScopes::new(); exec_scopes.assign_or_update_variable("a", any_box!(String::from("Hello"))); @@ -748,6 +767,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn scope_macro_test() { let scope_from_macro = scope![("a", Felt::one())]; let mut scope_verbose = ExecutionScopes::new(); @@ -761,6 +781,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_dictionary_pass() { let mut tracker = DictTracker::new_empty(relocatable!(2, 0)); tracker.insert_value( @@ -796,6 +817,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_dict_ptr_pass() { let tracker = DictTracker::new_empty(relocatable!(2, 0)); let mut dict_manager = DictManager::new(); @@ -823,6 +845,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_macro() { let tracker = DictTracker::new_empty(relocatable!(2, 0)); let mut dict_manager = DictManager::new(); @@ -836,6 +859,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_default_macro() { let tracker = DictTracker::new_default_dict( relocatable!(2, 0), @@ -853,6 +877,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn data_vec_test() { let data = vec_data!((1), ((2, 2)), (("49128305", 10)), (("3b6f00a9", 16))); assert_eq!(data[0], mayberelocatable!(1)); @@ -861,6 +886,7 @@ mod test { assert_eq!(data[3], mayberelocatable!(997130409)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_relocatable_to_indexes_test() { let reloc_1 = relocatable!(1, 5); let reloc_2 = relocatable!(0, 5); @@ -871,6 +897,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro() { let program = Program { builtins: Vec::new(), @@ -893,6 +920,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro_with_builtin() { let program = Program { builtins: vec![RANGE_CHECK_BUILTIN_NAME], @@ -915,6 +943,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro_custom_definition() { let program = Program { builtins: vec![RANGE_CHECK_BUILTIN_NAME], diff --git a/src/vm/context/run_context.rs b/src/vm/context/run_context.rs index 7a5839d634..5a49f2a2ea 100644 --- a/src/vm/context/run_context.rs +++ b/src/vm/context/run_context.rs @@ -101,13 +101,18 @@ impl RunContext { mod tests { use super::*; use crate::relocatable; + use crate::stdlib::string::ToString; use crate::types::instruction::{ApUpdate, FpUpdate, Opcode, PcUpdate, Res}; use crate::utils::test_utils::mayberelocatable; use crate::vm::errors::memory_errors::MemoryError; use assert_matches::assert_matches; use felt::Felt; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_dst_addr_for_ap_register() { let instruction = Instruction { off0: 1, @@ -136,6 +141,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_dst_addr_for_fp_register() { let instruction = Instruction { off0: 1, @@ -165,6 +171,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op0_addr_for_ap_register() { let instruction = Instruction { off0: 1, @@ -193,6 +200,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op0_addr_for_fp_register() { let instruction = Instruction { off0: 1, @@ -221,6 +229,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_fp_op1_addr() { let instruction = Instruction { off0: 1, @@ -249,6 +258,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_ap_op1_addr() { let instruction = Instruction { off0: 1, @@ -277,6 +287,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_imm_op1_addr_correct_off2() { let instruction = Instruction { off0: 1, @@ -305,6 +316,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_imm_op1_addr_incorrect_off2() { let instruction = Instruction { off0: 1, @@ -336,6 +348,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_op0_op1_addr_with_op0() { let instruction = Instruction { off0: 1, @@ -366,6 +379,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_with_no_relocatable_address() { let instruction = Instruction { off0: 1, @@ -398,6 +412,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_op0_op1_addr_without_op0() { let instruction = Instruction { off0: 1, diff --git a/src/vm/decoding/decoder.rs b/src/vm/decoding/decoder.rs index 106e7e7a0f..880b478996 100644 --- a/src/vm/decoding/decoder.rs +++ b/src/vm/decoding/decoder.rs @@ -146,9 +146,14 @@ fn decode_offset(offset: i64) -> isize { #[cfg(test)] mod decoder_test { use super::*; + use crate::stdlib::string::ToString; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_op1_reg() { let error = decode_instruction(0x294F800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidOp1Reg(3))); @@ -159,6 +164,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_pc_update() { let error = decode_instruction(0x29A8800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidPcUpdate(3))); @@ -166,6 +172,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_res_logic() { let error = decode_instruction(0x2968800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidRes(3))); @@ -173,6 +180,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_opcode() { let error = decode_instruction(0x3948800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidOpcode(3))); @@ -180,6 +188,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_ap_update() { let error = decode_instruction(0x2D48800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidApUpdate(3))); @@ -187,6 +196,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_no_immediate_given() { assert_matches!( decode_instruction(0x14A7800080008000, None), @@ -195,6 +205,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_call_add_jmp_add_imm_fp_fp() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -213,6 +224,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_ret_add1_jmp_rel_mul_fp_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -231,6 +243,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_assrt_add_jnz_mul_ap_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -249,6 +262,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_assrt_add2_jnz_uncon_op0_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -267,6 +281,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_nop_regu_regu_op1_op0_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -285,6 +300,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_offset_negative() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 diff --git a/src/vm/errors/cairo_run_errors.rs b/src/vm/errors/cairo_run_errors.rs index 3810343411..7684b29f2f 100644 --- a/src/vm/errors/cairo_run_errors.rs +++ b/src/vm/errors/cairo_run_errors.rs @@ -1,10 +1,14 @@ +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + use super::memory_errors::MemoryError; use super::vm_exception::VmException; use crate::types::errors::program_errors::ProgramError; use crate::vm::errors::{ runner_errors::RunnerError, trace_errors::TraceError, vm_errors::VirtualMachineError, }; -use thiserror::Error; #[derive(Debug, Error)] pub enum CairoRunError { diff --git a/src/vm/errors/exec_scope_errors.rs b/src/vm/errors/exec_scope_errors.rs index ec422dd32d..92e794a022 100644 --- a/src/vm/errors/exec_scope_errors.rs +++ b/src/vm/errors/exec_scope_errors.rs @@ -1,4 +1,7 @@ +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; #[derive(Eq, Hash, PartialEq, Debug, Error)] pub enum ExecScopeError { diff --git a/src/vm/errors/hint_errors.rs b/src/vm/errors/hint_errors.rs index 5479a8944f..e2ce4ec78d 100644 --- a/src/vm/errors/hint_errors.rs +++ b/src/vm/errors/hint_errors.rs @@ -1,6 +1,12 @@ +use crate::stdlib::prelude::*; + +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + use felt::Felt; use num_bigint::{BigInt, BigUint}; -use thiserror::Error; use crate::types::{ errors::math_errors::MathError, diff --git a/src/vm/errors/memory_errors.rs b/src/vm/errors/memory_errors.rs index afe99d6867..a6cf4eeb4f 100644 --- a/src/vm/errors/memory_errors.rs +++ b/src/vm/errors/memory_errors.rs @@ -1,5 +1,11 @@ -use felt::Felt; +use crate::stdlib::prelude::*; + +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + +use felt::Felt; use crate::types::{ errors::math_errors::MathError, diff --git a/src/vm/errors/runner_errors.rs b/src/vm/errors/runner_errors.rs index 2fe4bc0558..518fe75f14 100644 --- a/src/vm/errors/runner_errors.rs +++ b/src/vm/errors/runner_errors.rs @@ -1,4 +1,9 @@ -use std::collections::HashSet; +use crate::stdlib::{collections::HashSet, prelude::*}; + +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; use super::memory_errors::MemoryError; use crate::types::{ @@ -6,7 +11,6 @@ use crate::types::{ relocatable::{MaybeRelocatable, Relocatable}, }; use felt::Felt; -use thiserror::Error; #[derive(Debug, PartialEq, Error)] pub enum RunnerError { @@ -16,8 +20,6 @@ pub enum RunnerError { NoProgBase, #[error("Missing main()")] MissingMain, - #[error("Failed to write program output")] - WriteFail, #[error("Found None PC during VM initialization")] NoPC, #[error("Found None AP during VM initialization")] diff --git a/src/vm/errors/trace_errors.rs b/src/vm/errors/trace_errors.rs index 2f63144512..dce825e20d 100644 --- a/src/vm/errors/trace_errors.rs +++ b/src/vm/errors/trace_errors.rs @@ -1,5 +1,9 @@ -use crate::vm::errors::memory_errors::MemoryError; +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + +use crate::vm::errors::memory_errors::MemoryError; #[derive(Debug, PartialEq, Error)] pub enum TraceError { diff --git a/src/vm/errors/vm_errors.rs b/src/vm/errors/vm_errors.rs index 1f099b4f93..2ee743d006 100644 --- a/src/vm/errors/vm_errors.rs +++ b/src/vm/errors/vm_errors.rs @@ -1,3 +1,10 @@ +use crate::stdlib::prelude::*; + +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + use crate::{ types::{ errors::math_errors::MathError, @@ -9,8 +16,6 @@ use crate::{ }, }; use felt::Felt; -use std::error::Error; -use thiserror::Error; #[derive(Debug, Error)] pub enum VirtualMachineError { @@ -110,6 +115,8 @@ pub enum VirtualMachineError { MissingAccessedAddresses, #[error(transparent)] Math(#[from] MathError), + #[error("Failed to write the output builtin content")] + FailedToWriteOutput, #[error(transparent)] - Other(Box), + Other(anyhow::Error), } diff --git a/src/vm/errors/vm_exception.rs b/src/vm/errors/vm_exception.rs index 070214f72f..35145deab0 100644 --- a/src/vm/errors/vm_exception.rs +++ b/src/vm/errors/vm_exception.rs @@ -1,11 +1,13 @@ -use std::{ +use crate::stdlib::{ fmt::{self, Display}, - fs::File, - io::{BufReader, Read}, - path::Path, + prelude::*, + str, }; +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; use crate::{ hint_processor::{ @@ -229,7 +231,7 @@ impl Display for VmException { impl Location { /// Prints the location with the passed message. - pub fn to_string(&self, message: &String) -> String { + pub fn to_string(&self, message: &str) -> String { let msg_prefix = if message.is_empty() { "" } else { ": " }; format!( "{}:{}:{}{}{}", @@ -237,20 +239,26 @@ impl Location { ) } - pub fn to_string_with_content(&self, message: &String) -> String { + #[cfg(all(not(feature = "std"), feature = "alloc"))] + pub fn to_string_with_content(&self, message: &str) -> String { + self.to_string(message) + } + + #[cfg(feature = "std")] + pub fn to_string_with_content(&self, message: &str) -> String { let mut string = self.to_string(message); - let input_file_path = Path::new(&self.input_file.filename); - if let Ok(file) = File::open(input_file_path) { - let mut reader = BufReader::new(file); - string.push_str(&format!("\n{}", self.get_location_marks(&mut reader))); + let input_file_path = std::path::Path::new(&self.input_file.filename); + if let Ok(file_content) = std::fs::read(input_file_path) { + string.push_str(&format!("\n{}", self.get_location_marks(&file_content))); } string } - pub fn get_location_marks(&self, file_contents: &mut impl Read) -> String { + pub fn get_location_marks(&self, file_contents: &[u8]) -> String { let mut contents = String::new(); - // If this read fails, the string will be left empty, so we can ignore the result - let _ = file_contents.read_to_string(&mut contents); + if let Ok(content) = str::from_utf8(file_contents) { + contents.push_str(content); + } let split_lines: Vec<&str> = contents.split('\n').collect(); if !(0 < self.start_line && ((self.start_line - 1) as usize) < split_lines.len()) { return String::new(); @@ -275,8 +283,9 @@ impl Location { } #[cfg(test)] mod test { + use crate::stdlib::{boxed::Box, collections::HashMap}; use assert_matches::assert_matches; - use std::collections::HashMap; + #[cfg(feature = "std")] use std::path::Path; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; @@ -287,8 +296,12 @@ mod test { use crate::types::relocatable::Relocatable; use crate::utils::test_utils::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + use super::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_vm_exception_from_vm_error() { let pc = 0; let location = Location { @@ -321,6 +334,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_no_message() { let location = Location { end_line: 2, @@ -340,6 +354,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_message() { let location = Location { end_line: 2, @@ -359,6 +374,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_location_no_attributes() { let vm_excep = VmException { pc: 2, @@ -383,6 +399,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_location_with_attributes() { let vm_excep = VmException { pc: 2, @@ -407,6 +424,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_attributes_no_parent() { let location = Location { end_line: 2, @@ -441,6 +459,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_attributes_with_parent() { let location = Location { end_line: 2, @@ -484,6 +503,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_error_attr_value_some() { let attributes = vec![Attribute { name: String::from("Error message"), @@ -502,6 +522,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_error_attr_value_none() { let attributes = vec![Attribute { name: String::from("Error message"), @@ -517,6 +538,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_some() { let location = Location { end_line: 2, @@ -539,6 +561,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_none() { let location = Location { end_line: 2, @@ -561,6 +584,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_some_hint_index() { let location_a = Location { end_line: 2, @@ -597,12 +621,17 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_bad_dict_update() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_dict_update.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/bad_dict_update.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); + #[cfg(feature = "std")] + let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n dict_update{dict_ptr=my_dict}(key=2, prev_value=3, new_value=4);\n ^*************************************************************^\n"); + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n"); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -612,17 +641,35 @@ mod test { assert!(cairo_runner .run_until_pc(end, &mut vm, &mut hint_processor) .is_err()); - let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n dict_update{dict_ptr=my_dict}(key=2, prev_value=3, new_value=4);\n ^*************************************************************^\n"); assert_eq!(get_traceback(&vm, &cairo_runner), Some(expected_traceback)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_bad_usort() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_usort.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); + #[cfg(feature = "std")] + let expected_traceback = r"Cairo traceback (most recent call last): +cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) + let (output_len, output, multiplicities) = usort(input_len=3, input=input_array); + ^***********************************^ +cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) + verify_usort{output=output}( + ^**************************^ +cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) + verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value); + ^*******************************************************************************************^ +"; + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_traceback = r"Cairo traceback (most recent call last): +cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) +cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) +cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) +"; let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -632,11 +679,14 @@ mod test { assert!(cairo_runner .run_until_pc(end, &mut vm, &mut hint_processor) .is_err()); - let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97)\n let (output_len, output, multiplicities) = usort(input_len=3, input=input_array);\n ^***********************************^\ncairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30)\n verify_usort{output=output}(\n ^**************************^\ncairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60)\n verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value);\n ^*******************************************************************************************^\n"); - assert_eq!(get_traceback(&vm, &cairo_runner), Some(expected_traceback)); + assert_eq!( + get_traceback(&vm, &cairo_runner), + Some(expected_traceback.to_string()) + ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents_no_contents() { let location = Location { end_line: 2, @@ -656,6 +706,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents() { let location = Location { end_line: 5, @@ -668,13 +719,20 @@ mod test { start_col: 1, }; let message = String::from("Error at pc=0:75:"); + + #[cfg(feature = "std")] + let expected_message = "cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:\nfunc usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^"; + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_message = "cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:"; + assert_eq!( location.to_string_with_content(&message), - String::from("cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:\nfunc usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^") + expected_message.to_string() ) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents_no_file() { let location = Location { end_line: 5, @@ -696,6 +754,7 @@ mod test { } #[test] + #[cfg(feature = "std")] fn location_get_location_marks() { let location = Location { end_line: 5, @@ -708,15 +767,15 @@ mod test { start_col: 1, }; let input_file_path = Path::new(&location.input_file.filename); - let file = File::open(input_file_path).expect("Failed to open file"); - let mut reader = BufReader::new(file); + let file_content = std::fs::read(input_file_path).expect("Failed to open file"); assert_eq!( - location.get_location_marks(&mut reader), + location.get_location_marks(&file_content), String::from("func usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^") ) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_get_location_marks_empty_file() { let location = Location { end_line: 5, @@ -728,12 +787,14 @@ mod test { start_line: 5, start_col: 1, }; - let mut reader: &[u8] = &[]; - assert_eq!(location.get_location_marks(&mut reader), String::from("")) + let reader: &[u8] = &[]; + assert_eq!(location.get_location_marks(reader), String::from("")) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_bad_range_check_and_check_error_displayed() { + #[cfg(feature = "std")] let expected_error_string = r#"Error message: Failed range-check cairo_programs/bad_programs/bad_range_check.cairo:5:9: Error at pc=0:0: An ASSERT_EQ instruction failed: 4 != 5. @@ -753,11 +814,21 @@ cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) check_range(num - 1); ^******************^ "#; - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_range_check.json"), + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_error_string = r#"Error message: Failed range-check +cairo_programs/bad_programs/bad_range_check.cairo:5:9: Error at pc=0:0: +An ASSERT_EQ instruction failed: 4 != 5. +Cairo traceback (most recent call last): +cairo_programs/bad_programs/bad_range_check.cairo:23:5: (pc=0:29) +cairo_programs/bad_programs/bad_range_check.cairo:19:12: (pc=0:21) +cairo_programs/bad_programs/bad_range_check.cairo:19:33: (pc=0:17) +cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) +"#; + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/bad_range_check.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -772,7 +843,9 @@ cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_bad_usort_and_check_error_displayed() { + #[cfg(feature = "std")] let expected_error_string = r#"cairo_programs/bad_programs/bad_usort.cairo:79:5: Error at pc=0:75: Got an exception while executing a hint: unexpected verify multiplicity fail: positions length != 0 %{ assert len(positions) == 0 %} @@ -788,11 +861,19 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value); ^*******************************************************************************************^ "#; - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_usort.json"), + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_error_string = r#"cairo_programs/bad_programs/bad_usort.cairo:79:5: Error at pc=0:75: +Got an exception while executing a hint: unexpected verify multiplicity fail: positions length != 0 +Cairo traceback (most recent call last): +cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) +cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) +cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) +"#; + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -807,12 +888,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_value_from_simple_reference_ap_based() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); // This program uses a tempvar inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -825,12 +907,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn substitute_error_message_references_ap_based() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); // This program uses a tempvar inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -846,12 +929,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_value_from_simple_reference_complex() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_struct.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); // This program uses a struct inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -864,12 +948,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn substitute_error_message_references_complex() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_struct.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); // This program uses a struct inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); diff --git a/src/vm/hooks.rs b/src/vm/hooks.rs index dab0c4db39..883e1241ff 100644 --- a/src/vm/hooks.rs +++ b/src/vm/hooks.rs @@ -9,7 +9,7 @@ //! - pre_step_instruction, executed before each instruction_step in [step](VirtualMachine::step) //! - post_step_instruction, executed after each instruction_step in [step](VirtualMachine::step) -use std::{any::Any, collections::HashMap, sync::Arc}; +use crate::stdlib::{any::Any, collections::HashMap, prelude::*, sync::Arc}; use felt::Felt; @@ -124,8 +124,6 @@ impl VirtualMachine { #[cfg(test)] mod tests { - use std::path::Path; - use super::*; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -135,8 +133,11 @@ mod tests { #[test] fn empty_hooks() { - let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/sqrt.json"), + Some("main"), + ) + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); @@ -151,8 +152,11 @@ mod tests { #[test] fn hook_failure() { - let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/sqrt.json"), + Some("main"), + ) + .expect("Call to `Program::from_file()` failed."); fn before_first_step_hook( _vm: &mut VirtualMachine, @@ -218,8 +222,11 @@ mod tests { #[test] fn hook_success() { - let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/sqrt.json"), + Some("main"), + ) + .expect("Call to `Program::from_file()` failed."); fn before_first_step_hook( _vm: &mut VirtualMachine, diff --git a/src/vm/runners/builtin_runner/bitwise.rs b/src/vm/runners/builtin_runner/bitwise.rs index d4f5bc33ff..d5d5681785 100644 --- a/src/vm/runners/builtin_runner/bitwise.rs +++ b/src/vm/runners/builtin_runner/bitwise.rs @@ -1,3 +1,4 @@ +use crate::stdlib::vec::Vec; use crate::{ math_utils::safe_div_usize, types::{ @@ -228,18 +229,23 @@ impl BitwiseBuiltinRunner { mod tests { use super::*; use crate::relocatable; + use crate::stdlib::collections::HashMap; use crate::vm::errors::memory_errors::MemoryError; + use crate::vm::runners::builtin_runner::BuiltinRunner; use crate::vm::runners::builtin_runner::HASH_BUILTIN_NAME; + use crate::vm::vm_core::VirtualMachine; use crate::vm::vm_memory::memory::Memory; - use crate::vm::{runners::builtin_runner::BuiltinRunner, vm_core::VirtualMachine}; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, utils::test_utils::*, vm::runners::cairo_runner::CairoRunner, }; use felt::Felt; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -258,6 +264,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -281,6 +288,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -308,6 +316,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), false); @@ -331,6 +340,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -354,6 +364,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true).into(); @@ -400,6 +411,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -443,6 +455,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_and() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 7), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -451,6 +464,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_xor() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 8), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -459,6 +473,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_or() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 9), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -467,6 +482,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_incorrect_offset() { let memory = memory![((0, 3), 10), ((0, 4), 12), ((0, 5), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -475,6 +491,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_no_values_to_operate() { let memory = memory![((0, 5), 12), ((0, 7), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -483,6 +500,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -490,6 +508,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -504,6 +523,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -516,6 +536,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -536,6 +557,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -550,6 +572,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -562,6 +585,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -574,6 +598,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_a() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -583,6 +608,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_b() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -592,6 +618,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_c() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), diff --git a/src/vm/runners/builtin_runner/ec_op.rs b/src/vm/runners/builtin_runner/ec_op.rs index 152df6dd8c..2b0f5973ad 100644 --- a/src/vm/runners/builtin_runner/ec_op.rs +++ b/src/vm/runners/builtin_runner/ec_op.rs @@ -1,4 +1,4 @@ -use std::borrow::Cow; +use crate::stdlib::{borrow::Cow, prelude::*}; use crate::math_utils::{ec_add, ec_double, safe_div_usize}; use crate::types::instance_definitions::ec_op_instance_def::{ @@ -325,12 +325,13 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; + use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::{test_utils::*, CAIRO_PRIME}; - use crate::vm::errors::cairo_run_errors::CairoRunError; use crate::vm::errors::vm_errors::VirtualMachineError; use crate::vm::runners::builtin_runner::HASH_BUILTIN_NAME; use crate::vm::runners::cairo_runner::CairoRunner; + use crate::vm::security::verify_secure_runner; use crate::vm::vm_memory::memory::Memory; use crate::vm::{ errors::{memory_errors::MemoryError, runner_errors::RunnerError}, @@ -338,11 +339,13 @@ mod tests { vm_core::VirtualMachine, }; use felt::felt_str; - use std::collections::HashMap; - use std::path::Path; use EcOpBuiltinRunner; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -353,6 +356,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -376,6 +380,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -403,6 +408,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), false); @@ -426,6 +432,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -449,6 +456,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true).into(); @@ -493,6 +501,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -536,6 +545,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_on_curve_a() { let x = felt_str!( "874739451078007766457464989774322083649278607533249481151382481072868806602" @@ -551,6 +561,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_on_curve_b() { let x = felt_str!( "3139037544796708144595053687182055617920475701120786241351436619796497072089" @@ -566,6 +577,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_not_on_curve_a() { let x = felt_str!( "874739454078007766457464989774322083649278607533249481151382481072868806602" @@ -581,6 +593,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_not_on_curve_b() { let x = felt_str!( "3139037544756708144595053687182055617927475701120786241351436619796497072089" @@ -596,6 +609,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_ec_op_impl_valid_a() { let partial_sum = ( felt_str!( @@ -633,6 +647,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_ec_op_impl_valid_b() { let partial_sum = ( felt_str!( @@ -670,6 +685,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] #[allow(deprecated)] fn compute_ec_op_invalid_same_x_coordinate() { let partial_sum = (Felt::one(), Felt::new(9)); @@ -699,6 +715,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Data taken from this program execution: %builtins output ec_op from starkware.cairo.common.cairo_builtins import EcOpBuiltin @@ -766,6 +783,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_unfilled_input_cells() { let memory = memory![ ( @@ -805,6 +823,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_addr_not_an_output_cell() { let memory = memory![ ( @@ -851,6 +870,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_non_integer_input() { let memory = memory![ ( @@ -895,6 +915,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -902,6 +923,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -914,6 +936,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -924,6 +947,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -942,6 +966,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -954,6 +979,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -964,6 +990,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -974,6 +1001,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stackincluded_test() { let ec_op_builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -981,52 +1009,82 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_notincluded_test() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), false); assert_eq!(ec_op_builtin.initial_stack(), Vec::new()) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn catch_point_same_x() { - let program = Path::new("cairo_programs/bad_programs/ec_op_same_x.json"); - let cairo_run_config = crate::cairo_run::CairoRunConfig { - layout: "all", - ..crate::cairo_run::CairoRunConfig::default() - }; - let result = crate::cairo_run::cairo_run( - program, - &cairo_run_config, - &mut BuiltinHintProcessor::new_empty(), - ); + let program = include_bytes!("../../../../cairo_programs/bad_programs/ec_op_same_x.json"); + let mut cairo_runner = CairoRunner::new( + &Program::from_bytes(program, Some("main")).unwrap(), + "all", + false, + ) + .unwrap(); + let mut vm = VirtualMachine::new(false); + let end = cairo_runner.initialize(&mut vm).unwrap(); + + let hint_executor = &mut BuiltinHintProcessor::new_empty(); + + cairo_runner + .run_until_pc(end, &mut vm, hint_executor) + .unwrap(); + cairo_runner + .end_run(false, false, &mut vm, hint_executor) + .unwrap(); + + vm.verify_auto_deductions().unwrap(); + cairo_runner.read_return_values(&mut vm).unwrap(); + let result = verify_secure_runner(&cairo_runner, true, &mut vm); + assert!(result.is_err()); // We need to check this way because CairoRunError doens't implement PartialEq match result { - Err(CairoRunError::VirtualMachine(VirtualMachineError::RunnerError( - RunnerError::EcOpSameXCoordinate(_), - ))) => {} + Err(VirtualMachineError::RunnerError(RunnerError::EcOpSameXCoordinate(_))) => {} Err(_) => panic!("Wrong error returned, expected RunnerError::EcOpSameXCoordinate"), Ok(_) => panic!("Expected run to fail"), } } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn catch_point_not_in_curve() { - let program = Path::new("cairo_programs/bad_programs/ec_op_not_in_curve.json"); - let cairo_run_config = crate::cairo_run::CairoRunConfig { - layout: "all", - ..crate::cairo_run::CairoRunConfig::default() - }; - let result = crate::cairo_run::cairo_run( - program, - &cairo_run_config, - &mut BuiltinHintProcessor::new_empty(), - ); + let program = + include_bytes!("../../../../cairo_programs/bad_programs/ec_op_not_in_curve.json"); + + let mut cairo_runner = CairoRunner::new( + &Program::from_bytes(program, Some("main")).unwrap(), + "all", + false, + ) + .unwrap(); + let mut vm = VirtualMachine::new(false); + let end = cairo_runner.initialize(&mut vm).unwrap(); + + let hint_proccesor = &mut BuiltinHintProcessor::new_empty(); + cairo_runner + .run_until_pc(end, &mut vm, hint_proccesor) + .unwrap(); + + cairo_runner + .end_run(false, false, &mut vm, hint_proccesor) + .unwrap(); + + vm.verify_auto_deductions().unwrap(); + + cairo_runner.read_return_values(&mut vm).unwrap(); + + let result = verify_secure_runner(&cairo_runner, true, &mut vm); + assert!(result.is_err()); + // We need to check this way because CairoRunError doens't implement PartialEq match result { - Err(CairoRunError::VirtualMachine(VirtualMachineError::RunnerError( - RunnerError::PointNotOnCurve(_), - ))) => {} + Err(VirtualMachineError::RunnerError(RunnerError::PointNotOnCurve(_))) => {} Err(_) => panic!("Wrong error returned, expected RunnerError::EcOpSameXCoordinate"), Ok(_) => panic!("Expected run to fail"), } diff --git a/src/vm/runners/builtin_runner/hash.rs b/src/vm/runners/builtin_runner/hash.rs index 599f21363c..226c035607 100644 --- a/src/vm/runners/builtin_runner/hash.rs +++ b/src/vm/runners/builtin_runner/hash.rs @@ -1,4 +1,4 @@ -use std::cell::RefCell; +use crate::stdlib::{cell::RefCell, prelude::*}; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::pedersen_instance_def::{ @@ -215,6 +215,7 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; + use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::test_utils::*; use crate::vm::runners::cairo_runner::CairoRunner; @@ -224,9 +225,12 @@ mod tests { vm_core::VirtualMachine, }; use felt::felt_str; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = HashBuiltinRunner::new(10, true); @@ -237,6 +241,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -260,6 +265,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -287,6 +293,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_not_included() { let mut builtin = HashBuiltinRunner::new(10, false); @@ -310,6 +317,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -333,6 +341,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = HashBuiltinRunner::new(10, true).into(); @@ -378,6 +387,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = HashBuiltinRunner::new(10, true); @@ -421,6 +431,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_valid() { let memory = memory![((0, 3), 32), ((0, 4), 72), ((0, 5), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -439,6 +450,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_incorrect_offset() { let memory = memory![((0, 4), 32), ((0, 5), 72), ((0, 6), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -447,6 +459,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_no_values_to_hash() { let memory = memory![((0, 4), 72), ((0, 5), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -455,6 +468,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_already_computed() { let memory = memory![((0, 3), 32), ((0, 4), 72), ((0, 5), 0)]; let mut builtin = HashBuiltinRunner::new(8, true); @@ -464,6 +478,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = HashBuiltinRunner::new(256, true); @@ -471,6 +486,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let vm = vm!(); @@ -482,6 +498,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -491,6 +508,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -508,6 +526,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let vm = vm!(); @@ -519,6 +538,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -528,6 +548,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 39ee2ee19a..4fd7939132 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use crate::hint_processor::builtin_hint_processor::keccak_utils::left_pad_u64; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::keccak_instance_def::KeccakInstanceDef; @@ -248,6 +250,7 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; + use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::test_utils::*; use crate::vm::runners::cairo_runner::CairoRunner; @@ -257,10 +260,12 @@ mod tests { runners::builtin_runner::BuiltinRunner, vm_core::VirtualMachine, }; - use std::collections::HashMap; - use std::path::Path; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -272,6 +277,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -295,6 +301,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -321,6 +328,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_not_included() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), false); @@ -345,6 +353,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -368,6 +377,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -375,8 +385,11 @@ mod tests { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![0]); - let program = - Program::from_file(Path::new("cairo_programs/_keccak.json"), Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../../cairo_programs/_keccak.json"), + Some("main"), + ) + .unwrap(); let mut cairo_runner = cairo_runner!(program, "all"); @@ -395,6 +408,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -406,6 +420,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); @@ -413,6 +428,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let vm = vm!(); @@ -424,6 +440,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let mut vm = vm!(); @@ -433,6 +450,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let mut vm = vm!(); @@ -450,6 +468,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -462,6 +481,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -472,6 +492,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -482,6 +503,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stackincluded_test() { let keccak_builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); assert_eq!( @@ -491,12 +513,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_notincluded_test() { let keccak_builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), false); assert_eq!(keccak_builtin.initial_stack(), Vec::new()) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_memory_valid() { let memory = memory![ ((0, 16), 43), @@ -532,6 +556,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_non_reloc_address_err() { let memory = memory![ ((0, 4), 32), @@ -546,6 +571,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_offset_lt_input_cell_length_none() { let memory = memory![((0, 4), 32)]; let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); @@ -554,6 +580,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_offset_first_addr_error() { let memory = memory![ ((0, 16), 43), @@ -587,6 +614,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_expected_integer() { let memory = memory![((0, 0), (1, 2))]; @@ -606,6 +634,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_get_memory_err() { let memory = memory![((0, 35), 0)]; @@ -617,6 +646,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_memory_int_larger_than_bits() { let memory = memory![ ((0, 16), 43), @@ -657,6 +687,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_result() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); diff --git a/src/vm/runners/builtin_runner/mod.rs b/src/vm/runners/builtin_runner/mod.rs index 78e1b95677..c377529948 100644 --- a/src/vm/runners/builtin_runner/mod.rs +++ b/src/vm/runners/builtin_runner/mod.rs @@ -1,3 +1,4 @@ +use crate::stdlib::prelude::*; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use crate::vm::errors::memory_errors::{self, MemoryError}; use crate::vm::errors::runner_errors::RunnerError; @@ -451,7 +452,11 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -464,6 +469,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -474,6 +480,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -492,6 +499,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.clone().into(); @@ -499,6 +507,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.clone().into(); @@ -506,6 +515,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.clone().into(); @@ -513,6 +523,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.clone().into(); @@ -520,6 +531,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.clone().into(); @@ -527,6 +539,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -534,6 +547,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.clone().into(); @@ -541,6 +555,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.clone().into(); @@ -548,6 +563,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.clone().into(); @@ -555,6 +571,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.clone().into(); @@ -562,6 +579,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.clone().into(); @@ -569,6 +587,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -576,6 +595,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_keccak() { let keccak = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let builtin: BuiltinRunner = keccak.clone().into(); @@ -583,6 +603,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.into(); @@ -590,6 +611,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.into(); @@ -597,6 +619,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.into(); @@ -604,6 +627,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.into(); @@ -611,6 +635,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.into(); @@ -618,6 +643,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -625,6 +651,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_bitwise_with_items() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::new(10), @@ -671,6 +698,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_ec_op_with_items() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true)); @@ -714,6 +742,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_hash_with_items() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(10, true)); @@ -757,6 +786,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_range_check_with_items() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(10, 12, true)); @@ -800,6 +830,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_keccak_with_items() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::new(10, vec![200; 8]), @@ -812,6 +843,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -821,6 +853,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); let vm = vm!(); @@ -828,6 +861,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(1, true)); let vm = vm!(); @@ -835,6 +869,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -845,6 +880,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -853,6 +889,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_keccak() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -863,6 +900,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -870,6 +908,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -877,6 +916,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -884,6 +924,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -892,6 +933,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -902,6 +944,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -911,6 +954,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_keccak_zero_case() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -920,6 +964,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_keccak_non_zero_case() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -929,30 +974,35 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(16, true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses_test() { let bitwise_builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -973,6 +1023,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_for_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -981,6 +1032,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_empty_memory() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -992,6 +1044,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_empty_offsets() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -1005,6 +1058,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_bitwise_missing_memory_cells_with_offsets() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -1027,6 +1081,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_bitwise_missing_memory_cells() { let mut bitwise_builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -1054,6 +1109,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_hash_missing_memory_cells_with_offsets() { let builtin: BuiltinRunner = HashBuiltinRunner::new(8, true).into(); let mut vm = vm!(); @@ -1074,6 +1130,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_hash_missing_memory_cells() { let hash_builtin = HashBuiltinRunner::new(8, true); @@ -1092,6 +1149,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_missing_memory_cells_with_offsets() { let range_check_builtin = RangeCheckBuiltinRunner::new(8, 8, true); let builtin: BuiltinRunner = range_check_builtin.into(); @@ -1115,6 +1173,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_missing_memory_cells() { let builtin: BuiltinRunner = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); @@ -1131,6 +1190,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_empty() { let range_check_builtin = RangeCheckBuiltinRunner::new(8, 8, true); @@ -1144,6 +1204,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_validate_auto_deductions() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1166,6 +1227,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_empty() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1179,6 +1241,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_1_element() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1196,6 +1259,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_3_elements() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1214,6 +1278,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_missing_memory_cells_with_offsets() { let builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -1236,6 +1301,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_gap() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1268,6 +1334,7 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is a BitwiseBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_bitwise() { let builtin_runner: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1281,6 +1348,7 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is an EcOpBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_ec_op() { let builtin_runner: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -1294,6 +1362,7 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is a HashBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_hash() { let builtin_runner: BuiltinRunner = HashBuiltinRunner::new(8, true).into(); let mut vm = vm!(); @@ -1306,6 +1375,7 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is an OutputBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_output() { let builtin_runner: BuiltinRunner = OutputBuiltinRunner::new(true).into(); let mut vm = vm!(); @@ -1318,6 +1388,7 @@ mod tests { /// Test that get_used_perm_range_check_units() calls the corresponding /// method when the builtin is a RangeCheckBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_range_check() { let builtin_runner: BuiltinRunner = RangeCheckBuiltinRunner::new(8, 8, true).into(); let mut vm = vm!(); @@ -1328,6 +1399,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ratio_tests() { let bitwise_builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1348,6 +1420,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn bitwise_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1358,6 +1431,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn ec_op_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1368,6 +1442,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn hash_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1377,6 +1452,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn output_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1385,6 +1461,7 @@ mod tests { assert_eq!(output_builtin.get_used_instances(&vm.segments), Ok(4)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn range_check_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1395,6 +1472,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn runners_final_stack() { let mut builtins = vec![ BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( @@ -1422,6 +1500,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn runners_set_stop_ptr() { let builtins = vec![ BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( diff --git a/src/vm/runners/builtin_runner/output.rs b/src/vm/runners/builtin_runner/output.rs index 618faa0f1a..131d23c4ee 100644 --- a/src/vm/runners/builtin_runner/output.rs +++ b/src/vm/runners/builtin_runner/output.rs @@ -1,3 +1,4 @@ +use crate::stdlib::prelude::*; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use crate::vm::errors::memory_errors::MemoryError; use crate::vm::errors::runner_errors::RunnerError; @@ -126,6 +127,7 @@ impl Default for OutputBuiltinRunner { mod tests { use super::*; use crate::relocatable; + use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory::Memory; use crate::{ utils::test_utils::*, @@ -134,9 +136,12 @@ mod tests { vm_core::VirtualMachine, }, }; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = OutputBuiltinRunner::new(true); @@ -147,6 +152,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = OutputBuiltinRunner::new(true); @@ -170,6 +176,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = OutputBuiltinRunner::new(true); @@ -197,6 +204,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = OutputBuiltinRunner::new(false); @@ -220,6 +228,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = OutputBuiltinRunner::new(true); @@ -243,6 +252,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = OutputBuiltinRunner::new(true).into(); @@ -257,6 +267,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = OutputBuiltinRunner::new(true); @@ -266,6 +277,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_output() { let mut builtin = OutputBuiltinRunner::new(true); let mut segments = MemorySegmentManager::new(); @@ -274,6 +286,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_output_with_base() { let mut builtin = OutputBuiltinRunner::new(true); builtin.base = 1; @@ -286,6 +299,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = OutputBuiltinRunner::new(true); @@ -293,6 +307,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -304,6 +319,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -313,6 +329,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -330,6 +347,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -341,6 +359,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -350,6 +369,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -359,6 +379,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_used_instances_missing_segments() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let memory_segment_manager = MemorySegmentManager::new(); @@ -370,6 +391,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_used_instances_valid() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut memory_segment_manager = MemorySegmentManager::new(); @@ -379,6 +401,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_deduce_memory_cell_output_builtin() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -401,6 +424,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_add_validation_rule() { let builtin = OutputBuiltinRunner::new(true); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/range_check.rs b/src/vm/runners/builtin_runner/range_check.rs index edb5e34f46..7eb286a570 100644 --- a/src/vm/runners/builtin_runner/range_check.rs +++ b/src/vm/runners/builtin_runner/range_check.rs @@ -1,3 +1,9 @@ +use crate::stdlib::{ + cmp::{max, min}, + ops::Shl, + prelude::*, +}; + use crate::{ math_utils::safe_div_usize, types::{ @@ -19,10 +25,6 @@ use crate::{ use felt::Felt; use num_integer::Integer; use num_traits::{One, ToPrimitive, Zero}; -use std::{ - cmp::{max, min}, - ops::Shl, -}; use super::RANGE_CHECK_BUILTIN_NAME; @@ -248,6 +250,7 @@ impl RangeCheckBuiltinRunner { mod tests { use super::*; use crate::relocatable; + use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory::Memory; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -258,9 +261,12 @@ mod tests { vm_core::VirtualMachine, }, }; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -271,6 +277,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -294,6 +301,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -321,6 +329,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, false); @@ -344,6 +353,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -367,6 +377,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = RangeCheckBuiltinRunner::new(10, 12, true).into(); @@ -412,6 +423,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -455,6 +467,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_range_check() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -463,6 +476,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_range_check_with_base() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); builtin.base = 1; @@ -475,6 +489,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); @@ -482,6 +497,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let vm = vm!(); @@ -493,6 +509,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -502,6 +519,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -519,18 +537,21 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_base() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); assert_eq!(builtin.base(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_ratio() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); assert_eq!(builtin.ratio(), 8); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let vm = vm!(); @@ -542,6 +563,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -551,6 +573,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -560,6 +583,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_a() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -567,6 +591,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_b() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![ @@ -579,6 +604,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_c() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![ @@ -593,6 +619,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_empty_memory() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = Memory::new(); @@ -601,6 +628,7 @@ mod tests { /// Test that the method get_used_perm_range_check_units works as intended. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units() { let builtin_runner = RangeCheckBuiltinRunner::new(8, 8, true); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/signature.rs b/src/vm/runners/builtin_runner/signature.rs index 1095de4a93..b9c29f7c33 100644 --- a/src/vm/runners/builtin_runner/signature.rs +++ b/src/vm/runners/builtin_runner/signature.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; + use crate::{ math_utils::safe_div_usize, types::{ @@ -19,7 +21,6 @@ use crate::{ use felt::Felt; use num_integer::div_ceil; use starknet_crypto::{verify, FieldElement, Signature}; -use std::{cell::RefCell, collections::HashMap, rc::Rc}; use super::SIGNATURE_BUILTIN_NAME; @@ -270,7 +271,11 @@ mod tests { }, }; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_min_step_not_reached() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -285,6 +290,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_valid() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let mut vm = vm!(); @@ -294,6 +300,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_ecdsa() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut segments = MemorySegmentManager::new(); @@ -302,6 +309,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin: BuiltinRunner = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true).into(); @@ -313,6 +321,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -336,6 +345,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -363,6 +373,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -386,6 +397,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -393,6 +405,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -407,6 +420,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -419,6 +433,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -439,6 +454,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -453,6 +469,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -465,6 +482,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -477,6 +495,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_range_check_with_base() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); builtin.base = 1; @@ -489,12 +508,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_not_included_test() { let ecdsa_builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), false); assert_eq!(ecdsa_builtin.initial_stack(), Vec::new()) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_test() { let memory = Memory::new(); let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -503,18 +524,21 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_ratio() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); assert_eq!(builtin.ratio(), 512); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_base() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); assert_eq!(builtin.base(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_memory_segment_addresses() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -522,6 +546,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell() { let memory = Memory::new(); let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -530,6 +555,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_safe_div_fail() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -541,6 +567,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_safe_div_fail() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -559,6 +586,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_insufficient_allocated() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -573,6 +601,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_invalid_stop_pointer() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -588,6 +617,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_no_used_instances() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index 8f210c33dd..4eeac14a8e 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -1,3 +1,10 @@ +use crate::stdlib::{ + any::Any, + collections::{HashMap, HashSet}, + ops::{Add, Sub}, + prelude::*, +}; + use crate::{ hint_processor::hint_processor_definition::{HintProcessor, HintReference}, math_utils::safe_div_usize, @@ -39,12 +46,6 @@ use crate::{ use felt::Felt; use num_integer::div_rem; use num_traits::Zero; -use std::{ - any::Any, - collections::{HashMap, HashSet}, - io, - ops::{Add, Sub}, -}; use super::builtin_runner::{ KeccakBuiltinRunner, BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, @@ -70,6 +71,7 @@ impl From> for CairoArg { } } +#[derive(Debug)] pub struct CairoRunner { pub(crate) program: Program, layout: CairoLayout, @@ -238,6 +240,7 @@ impl CairoRunner { self.layout._name.clone(), )); } + drop(inserted_builtins); vm.builtin_runners = builtin_runners; Ok(()) @@ -835,50 +838,6 @@ impl CairoRunner { }) } - pub fn get_output(&mut self, vm: &mut VirtualMachine) -> Result { - let mut output = Vec::::new(); - self.write_output(vm, &mut output)?; - let output = String::from_utf8(output).map_err(|_| RunnerError::FailedStringConversion)?; - Ok(output) - } - - /// Writes the values hosted in the output builtin's segment. - /// Does nothing if the output builtin is not present in the program. - pub fn write_output( - &mut self, - vm: &mut VirtualMachine, - stdout: &mut dyn io::Write, - ) -> Result<(), RunnerError> { - let (_, builtin) = match vm - .builtin_runners - .iter() - .find(|(k, _)| k == &OUTPUT_BUILTIN_NAME) - { - Some(x) => x, - _ => return Ok(()), - }; - - let segment_used_sizes = vm.segments.compute_effective_sizes(); - let segment_index = builtin.base(); - #[allow(deprecated)] - for i in 0..segment_used_sizes[segment_index] { - let formatted_value = match vm - .segments - .memory - .get(&Relocatable::from((segment_index as isize, i))) - { - Some(val) => match val.as_ref() { - MaybeRelocatable::Int(num) => format!("{}", num.to_bigint()), - MaybeRelocatable::RelocatableValue(rel) => format!("{}", rel), - }, - _ => "".to_string(), - }; - writeln!(stdout, "{formatted_value}").map_err(|_| RunnerError::WriteFail)?; - } - - Ok(()) - } - // Finalizes the segments. // Note: // 1. end_run() must precede a call to this method. @@ -1202,6 +1161,7 @@ impl Sub for ExecutionResources { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::collections::{HashMap, HashSet}; use crate::vm::vm_memory::memory::MemoryCell; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ @@ -1215,12 +1175,12 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::One; - use std::{ - collections::{HashMap, HashSet}, - path::Path, - }; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_usage_ok_case() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; @@ -1232,6 +1192,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_usage_err_case() { let program = program!(); @@ -1255,6 +1216,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_builtins_with_disordered_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; @@ -1264,6 +1226,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_cairo_runner_with_ordered_but_missing_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME]; @@ -1272,6 +1235,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_with_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1305,6 +1269,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_no_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1333,6 +1298,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_empty_data_and_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1353,6 +1319,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_some_data_empty_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!( @@ -1375,6 +1342,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_empty_data_some_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1391,6 +1359,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_no_program_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1429,6 +1398,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_entrypoint_empty_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1450,6 +1420,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_entrypoint_some_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1500,6 +1471,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(main = Some(1),); @@ -1512,12 +1484,16 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_program_segment_accessed_addrs() { // This test checks that all addresses from the program segment are marked as accessed at VM state initialization. // The fibonacci program has 24 instructions, so there should be 24 accessed addresses, // from (0, 0) to (0, 23). - let program = Program::from_file(Path::new("cairo_programs/fibonacci.json"), Some("main")) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/fibonacci.json"), + Some("main"), + ) + .unwrap(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); @@ -1532,6 +1508,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_no_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(main = Some(1),); @@ -1548,6 +1525,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_with_range_check_valid() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(builtins = vec![RANGE_CHECK_BUILTIN_NAME], main = Some(1),); @@ -1576,6 +1554,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_with_range_check_invalid() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(builtins = vec![RANGE_CHECK_BUILTIN_NAME], main = Some(1),); @@ -1599,6 +1578,7 @@ mod tests { //Integration tests for initialization phase #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: func myfunc(a: felt) -> (r: felt): let b = a * 2 @@ -1669,6 +1649,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -1746,6 +1727,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -1840,6 +1822,7 @@ mod tests { //Integration tests for initialization + execution phase #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: func myfunc(a: felt) -> (r: felt): let b = a * 2 @@ -1909,6 +1892,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -2009,6 +1993,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2121,6 +2106,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output range_check @@ -2280,6 +2266,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Memory from this test is taken from a cairo program execution Program used: func main(): @@ -2379,6 +2366,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output @@ -2534,6 +2522,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output @@ -2701,7 +2690,8 @@ mod tests { } #[test] - fn write_output_from_preset_memory() { + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] + fn get_output_from_preset_memory() { let program = program![OUTPUT_BUILTIN_NAME]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); @@ -2712,12 +2702,14 @@ mod tests { vm.segments = segments![((2, 0), 1), ((2, 1), 2)]; vm.segments.segment_used_sizes = Some(vec![0, 0, 2]); - let mut stdout = Vec::::new(); - cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); - assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n2\n"))); + + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "1\n2\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2728,7 +2720,7 @@ mod tests { serialize_word(a) return() end */ - fn write_output_from_program() { + fn get_output_from_program() { //Initialization Phase let program = program!( builtins = vec![OUTPUT_BUILTIN_NAME], @@ -2769,12 +2761,13 @@ mod tests { Ok(()) ); - let mut stdout = Vec::::new(); - cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); - assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n17\n"))); + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "1\n17\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2809,16 +2802,14 @@ mod tests { Ok(()) ); - let mut stdout = Vec::::new(); - cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); - assert_eq!( - String::from_utf8(stdout), - Ok(String::from("\n2:0\n")) - ); + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "\n2:0\n"); } #[test] - fn write_output_from_preset_memory_neg_output() { + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] + fn get_output_from_preset_memory_neg_output() { let program = program![OUTPUT_BUILTIN_NAME]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); @@ -2834,14 +2825,16 @@ mod tests { ) )]; vm.segments.segment_used_sizes = Some(vec![0, 0, 1]); - let mut stdout = Vec::::new(); - cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); - assert_eq!(String::from_utf8(stdout), Ok(String::from("-1\n"))); + + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "-1\n"); } - /// Test that `write_output()` works when the `output` builtin is not the first one. + /// Test that `get_output()` works when the `output` builtin is not the first one. #[test] - fn write_output_unordered_builtins() { + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] + fn get_output_unordered_builtins() { //Initialization Phase let program = program!( builtins = vec![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME], @@ -2895,14 +2888,13 @@ mod tests { Ok(()) ); - let mut stdout = Vec::::new(); - cairo_runner - .write_output(&mut vm, &mut stdout) - .expect("Call to `write_output()` failed."); - assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n17\n"))); + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "1\n17\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_all_builtins_in_order() { let program = program![ OUTPUT_BUILTIN_NAME, @@ -2922,6 +2914,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -2988,6 +2981,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -3058,6 +3052,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -3167,6 +3162,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_constants() { let program_constants = HashMap::from([ ("MAX".to_string(), Felt::new(300)), @@ -3178,6 +3174,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_missing_segment_used_sizes() { let program = program!(); @@ -3195,6 +3192,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty() { let program = program!(); @@ -3207,6 +3205,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty_builtins() { let program = program!(); @@ -3221,6 +3220,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty_accesses() { let program = program!(); @@ -3238,6 +3238,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes() { let program = program!(); @@ -3259,6 +3260,7 @@ mod tests { /// Test that check_diluted_check_usage() works without a diluted pool /// instance. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_without_pool_instance() { let program = program!(); @@ -3271,6 +3273,7 @@ mod tests { /// Test that check_diluted_check_usage() works without builtin runners. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_without_builtin_runners() { let program = program!(); @@ -3285,6 +3288,7 @@ mod tests { /// Test that check_diluted_check_usage() fails when there aren't enough /// allocated units. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_insufficient_allocated_cells() { let program = program!(); @@ -3304,6 +3308,7 @@ mod tests { /// Test that check_diluted_check_usage() succeeds when all the conditions /// are met. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage() { let program = program!(); @@ -3319,6 +3324,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_run_already_finished() { let program = program!(); @@ -3336,6 +3342,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run() { let program = program!(); @@ -3358,12 +3365,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_proof_mode_insufficient_allocated_cells() { - let program = Program::from_file( - Path::new("cairo_programs/proof_programs/fibonacci.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/proof_programs/fibonacci.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", true); @@ -3380,6 +3388,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtin_segments_info_empty() { let program = program!(); @@ -3390,6 +3399,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtin_segments_info_base_not_finished() { let program = program!(); @@ -3407,6 +3417,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources_trace_not_enabled() { let program = program!(); @@ -3425,6 +3436,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources_empty_builtins() { let program = program!(); @@ -3444,6 +3456,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources() { let program = program!(); @@ -3469,6 +3482,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_not_ended() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3480,6 +3494,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_no_prog_base() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3493,6 +3508,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_no_exec_base() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3507,6 +3523,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_noproof_mode() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3521,6 +3538,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_emptyproof_mode() { let program = program!(); let mut cairo_runner = cairo_runner!(program, "plain", true); @@ -3534,6 +3552,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_not_emptyproof_mode_empty_execution_public_memory() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -3566,6 +3585,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_not_emptyproof_mode_with_execution_public_memory() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4)]; @@ -3605,6 +3625,7 @@ mod tests { /// Test that ensures get_perm_range_check_limits() returns an error when /// trace is not enabled. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_trace_not_enabled() { let program = program!(); @@ -3622,6 +3643,7 @@ mod tests { /// Test that ensures get_perm_range_check_limits() returns None when the /// trace is empty (get_perm_range_check_limits returns None). #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_empty() { let program = program!(); @@ -3635,6 +3657,7 @@ mod tests { /// Test that get_perm_range_check_limits() works correctly when there are /// no builtins. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_no_builtins() { let program = program!(); @@ -3673,6 +3696,7 @@ mod tests { /// Test that get_perm_range_check_limits() works correctly when there are /// builtins. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits() { let program = program!(); @@ -3701,6 +3725,7 @@ mod tests { /// Test that check_range_check_usage() returns successfully when trace is /// not enabled. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_perm_range_limits_none() { let program = program!(); @@ -3714,6 +3739,7 @@ mod tests { /// Test that check_range_check_usage() returns successfully when all the /// conditions are met. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_without_builtins() { let program = program!(); @@ -3736,6 +3762,7 @@ mod tests { /// Test that check_range_check_usage() returns an error if there are /// insufficient allocated cells. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_insufficient_allocated_cells() { let program = program!(); @@ -3763,6 +3790,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_fp_is_none_without_initialization() { let program = program!(); @@ -3772,6 +3800,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_fp_can_be_obtained() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -3790,6 +3819,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_valid_case() { let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; let mut cairo_runner = cairo_runner!(program); @@ -3802,6 +3832,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_get_used_cells_and_allocated_size_error() { let program = program!(); @@ -3829,6 +3860,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_check_memory_usage_error() { let program = program!(); @@ -3854,6 +3886,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_check_diluted_check_usage_error() { let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; let cairo_runner = cairo_runner!(program); @@ -3870,6 +3903,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_all_builtins() { let program = program!(); @@ -3892,6 +3926,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_all_builtins_maintain_program_order() { let program = program![ HASH_BUILTIN_NAME, @@ -3918,6 +3953,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_runner() { let program = program!(); @@ -3956,6 +3992,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_plain_one_builtin() { let program = program![OUTPUT_BUILTIN_NAME]; let mut vm = vm!(); @@ -3970,6 +4007,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_plain_two_builtins() { let program = program![OUTPUT_BUILTIN_NAME, HASH_BUILTIN_NAME]; let mut vm = vm!(); @@ -3984,6 +4022,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_small_two_builtins() { let program = program![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME]; let mut vm = vm!(); @@ -3997,6 +4036,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint_proof_mode_empty_program() { let program = program!(start = Some(0), end = Some(0), main = Some(8),); let mut runner = cairo_runner!(program); @@ -4015,6 +4055,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint_proof_mode_empty_program_two_builtins() { let program = program!( start = Some(0), @@ -4039,6 +4080,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn can_get_the_runner_program_builtins() { let program = program!( start = Some(0), @@ -4052,6 +4094,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main_default() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4078,6 +4121,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4118,6 +4162,7 @@ mod tests { /// Test that set_entrypoint() fails when the entrypoint doesn't exist. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main_non_existent() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4144,6 +4189,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4166,6 +4212,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test_with_run_not_ended() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4182,6 +4229,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test_with_segments_finalized() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4199,6 +4247,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_one_builtin_empty() { let mut program = program![OUTPUT_BUILTIN_NAME]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4229,6 +4278,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_one_builtin_one_element() { let mut program = program![OUTPUT_BUILTIN_NAME]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4259,6 +4309,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_two_builtins() { let mut program = program![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4304,6 +4355,7 @@ mod tests { /// Test that add_additional_hash_builtin() creates an additional builtin. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_additional_hash_builtin() { let program = program!(); let cairo_runner = cairo_runner!(program); @@ -4331,6 +4383,7 @@ mod tests { /// Test that add_additional_hash_builtin() replaces the created runner if called multiple /// times. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_additional_hash_builtin_replace() { let program = program!(); let cairo_runner = cairo_runner!(program); @@ -4357,9 +4410,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_from_entrypoint_custom_program_test() { - let program = - Program::from_file(Path::new("cairo_programs/example_program.json"), None).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/example_program.json"), + None, + ) + .unwrap(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(true); //this true expression dictates that the trace is enabled let mut hint_processor = BuiltinHintProcessor::new_empty(); @@ -4418,6 +4475,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_arg_from_single() { let expected = CairoArg::Single(MaybeRelocatable::from((0, 0))); let value = MaybeRelocatable::from((0, 0)); @@ -4425,6 +4483,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_arg_from_array() { let expected = CairoArg::Array(vec![MaybeRelocatable::from((0, 0))]); let value = vec![MaybeRelocatable::from((0, 0))]; @@ -4432,7 +4491,7 @@ mod tests { } fn setup_execution_resources() -> (ExecutionResources, ExecutionResources) { - let mut builtin_instance_counter: HashMap = HashMap::new(); + let mut builtin_instance_counter: HashMap = HashMap::new(); builtin_instance_counter.insert(OUTPUT_BUILTIN_NAME.to_string(), 8); let execution_resources_1 = ExecutionResources { @@ -4454,6 +4513,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn execution_resources_add() { let (execution_resources_1, execution_resources_2) = setup_execution_resources(); let combined_resources = execution_resources_1 + execution_resources_2; @@ -4473,6 +4533,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn execution_resources_sub() { let (execution_resources_1, execution_resources_2) = setup_execution_resources(); @@ -4493,9 +4554,10 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_from_entrypoint_substitute_error_message_test() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_function.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_function.json"), None, ) .unwrap(); @@ -4534,9 +4596,10 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_range_check_builtin() { - let program = Program::from_file( - Path::new("cairo_programs/assert_le_felt_hint.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/assert_le_felt_hint.json"), Some("main"), ) .unwrap(); @@ -4556,9 +4619,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_4_builtins() { - let program = - Program::from_file(Path::new("cairo_programs/integration.json"), Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/integration.json"), + Some("main"), + ) + .unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); @@ -4575,9 +4642,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_no_builtins() { - let program = - Program::from_file(Path::new("cairo_programs/fibonacci.json"), Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/fibonacci.json"), + Some("main"), + ) + .unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); @@ -4594,10 +4665,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn filter_unused_builtins_test() { - let program = - Program::from_file(Path::new("cairo_programs/integration.json"), Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/integration.json"), + Some("main"), + ) + .unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); diff --git a/src/vm/security.rs b/src/vm/security.rs index 0ad3d994ed..12cb2689e7 100644 --- a/src/vm/security.rs +++ b/src/vm/security.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use num_traits::ToPrimitive; use super::{ @@ -81,6 +83,7 @@ pub fn verify_secure_runner( mod test { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; + use crate::stdlib::collections::HashMap; use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; use crate::vm::errors::memory_errors::MemoryError; @@ -91,9 +94,12 @@ mod test { use assert_matches::assert_matches; use felt::Felt; use num_traits::Zero; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_without_program_base() { let program = program!(); @@ -107,6 +113,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_empty_memory() { let program = program!(main = Some(0),); @@ -119,6 +126,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_program_access_out_of_bounds() { let program = program!(main = Some(0),); @@ -137,6 +145,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_builtin_access_out_of_bounds() { let program = program!(main = Some(0), builtins = vec![RANGE_CHECK_BUILTIN_NAME],); @@ -154,6 +163,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_builtin_access_correct() { let program = program!(main = Some(0), builtins = vec![RANGE_CHECK_BUILTIN_NAME],); @@ -173,6 +183,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_success() { let program = program!( data = vec![ @@ -200,6 +211,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_temporary_memory_properly_relocated() { let program = program!( data = vec![ @@ -227,6 +239,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_temporary_memory_not_fully_relocated() { let program = program!( data = vec![ diff --git a/src/vm/trace/mod.rs b/src/vm/trace/mod.rs index 6f699c403a..a0e3794ffb 100644 --- a/src/vm/trace/mod.rs +++ b/src/vm/trace/mod.rs @@ -4,9 +4,9 @@ use super::{ errors::{memory_errors::MemoryError, vm_errors::VirtualMachineError}, vm_memory::memory::Memory, }; +use crate::stdlib::borrow::Cow; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use num_traits::ToPrimitive; -use std::borrow::Cow; pub mod trace_entry; @@ -56,9 +56,13 @@ mod test { use crate::{utils::test_utils::*, vm::errors::memory_errors::MemoryError}; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + /// Test that get_perm_range_check_limits() works as intended with an empty /// trace. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_empty_trace() { let trace = &[]; let memory = Memory::new(); @@ -69,6 +73,7 @@ mod test { /// Test that get_perm_range_check_limits() works as intended with a single /// trace element. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_single_element() { let trace = &[TraceEntry { pc: (0, 0).into(), @@ -86,6 +91,7 @@ mod test { /// Test that get_perm_range_check_limits() works as intended with multiple /// trace elements. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_multiple_elements() { let trace = &[ TraceEntry { diff --git a/src/vm/trace/trace_entry.rs b/src/vm/trace/trace_entry.rs index ce27abb48e..b9221a7d2d 100644 --- a/src/vm/trace/trace_entry.rs +++ b/src/vm/trace/trace_entry.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use crate::vm::errors::trace_errors::TraceError; use crate::{types::relocatable::Relocatable, vm::errors::memory_errors::MemoryError}; use serde::{Deserialize, Serialize}; @@ -37,6 +39,7 @@ mod tests { use super::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value() { let value = Relocatable { segment_index: 2, @@ -49,7 +52,11 @@ mod tests { ); } + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value_no_relocation() { let value = Relocatable { segment_index: 2, @@ -65,6 +72,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_temp_segment_address() { let value = Relocatable { segment_index: -2, diff --git a/src/vm/vm_core.rs b/src/vm/vm_core.rs index f580a70ae6..30677aa49e 100644 --- a/src/vm/vm_core.rs +++ b/src/vm/vm_core.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, borrow::Cow, collections::HashMap, prelude::*}; + use crate::{ hint_processor::hint_processor_definition::HintProcessor, serde::deserialize_program::ApTracking, @@ -21,11 +23,13 @@ use crate::{ vm_memory::memory_segments::MemorySegmentManager, }, }; + use felt::Felt; use num_traits::{ToPrimitive, Zero}; -use std::{any::Any, borrow::Cow, collections::HashMap}; -use super::runners::builtin_runner::{RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME}; +use super::runners::builtin_runner::{ + OUTPUT_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, +}; const MAX_TRACEBACK_ENTRIES: u32 = 20; @@ -940,9 +944,41 @@ impl VirtualMachine { self.segments.gen_arg(arg) } - /// Calls MemorySegmentManager::compute_effective_sizes() - pub fn compute_effective_sizes(&mut self) -> &Vec { - self.segments.compute_effective_sizes() + /// Write the values hosted in the output builtin's segment. + /// Does nothing if the output builtin is not present in the program. + pub fn write_output( + &mut self, + writer: &mut impl core::fmt::Write, + ) -> Result<(), VirtualMachineError> { + let (_, builtin) = match self + .builtin_runners + .iter() + .find(|(k, _)| k == &OUTPUT_BUILTIN_NAME) + { + Some(x) => x, + _ => return Ok(()), + }; + + let segment_used_sizes = self.segments.compute_effective_sizes(); + let segment_index = builtin.base(); + #[allow(deprecated)] + for i in 0..segment_used_sizes[segment_index] { + let formatted_value = match self + .segments + .memory + .get(&Relocatable::from((segment_index as isize, i))) + { + Some(val) => match val.as_ref() { + MaybeRelocatable::Int(num) => format!("{}", num.to_bigint()), + MaybeRelocatable::RelocatableValue(rel) => format!("{}", rel), + }, + _ => "".to_string(), + }; + writeln!(writer, "{formatted_value}") + .map_err(|_| VirtualMachineError::FailedToWriteOutput)?; + } + + Ok(()) } } @@ -1046,6 +1082,8 @@ impl VirtualMachineBuilder { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::collections::HashMap; + use crate::types::program::Program; use crate::vm::runners::builtin_runner::{ BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, }; @@ -1061,7 +1099,6 @@ mod tests { bitwise_instance_def::BitwiseInstanceDef, ec_op_instance_def::EcOpInstanceDef, }, instruction::{Op1Addr, Register}, - program::Program, relocatable::Relocatable, }, utils::test_utils::*, @@ -1074,12 +1111,14 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::collections::HashMap; use felt::felt_str; - use std::path::Path; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_successful_without_imm() { let mut vm = vm!(); vm.segments = segments![((0, 0), 5)]; @@ -1090,6 +1129,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_successful_with_imm() { let mut vm = vm!(); @@ -1106,6 +1146,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_unsuccesful() { let vm = vm!(); assert_matches!( @@ -1115,6 +1156,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_ap_plus2() { let instruction = Instruction { off0: 1, @@ -1148,6 +1190,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_dst() { let instruction = Instruction { off0: 1, @@ -1181,6 +1224,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_regular() { let instruction = Instruction { off0: 1, @@ -1214,6 +1258,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_dst_num() { let instruction = Instruction { off0: 1, @@ -1248,6 +1293,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add_with_res() { let instruction = Instruction { off0: 1, @@ -1284,6 +1330,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add_without_res() { let instruction = Instruction { off0: 1, @@ -1319,6 +1366,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add1() { let instruction = Instruction { off0: 1, @@ -1355,6 +1403,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add2() { let instruction = Instruction { off0: 1, @@ -1391,6 +1440,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_regular() { let instruction = Instruction { off0: 1, @@ -1427,6 +1477,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_regular_instruction_no_imm() { let instruction = Instruction { off0: 1, @@ -1460,6 +1511,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_regular_instruction_has_imm() { let instruction = Instruction { off0: 1, @@ -1493,6 +1545,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_with_res() { let instruction = Instruction { off0: 1, @@ -1526,6 +1579,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_without_res() { let instruction = Instruction { off0: 1, @@ -1561,6 +1615,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_with_int_res() { let instruction = Instruction { off0: 1, @@ -1595,6 +1650,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_without_res() { let instruction = Instruction { off0: 1, @@ -1627,6 +1683,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_with_non_int_res() { let instruction = Instruction { off0: 1, @@ -1658,6 +1715,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jnz_dst_is_zero() { let instruction = Instruction { off0: 1, @@ -1691,6 +1749,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jnz_dst_is_not_zero() { let instruction = Instruction { off0: 1, @@ -1724,6 +1783,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_registers_all_regular() { let instruction = Instruction { off0: 1, @@ -1762,6 +1822,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_registers_mixed_types() { let instruction = Instruction { off0: 1, @@ -1798,18 +1859,21 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_int_value() { let value = MaybeRelocatable::Int(Felt::new(1)); assert!(!VirtualMachine::is_zero(&value)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_relocatable_value() { let value = MaybeRelocatable::from((1, 2)); assert!(!VirtualMachine::is_zero(&value)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_call() { let instruction = Instruction { off0: 1, @@ -1838,6 +1902,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_add_with_optionals() { let instruction = Instruction { off0: 1, @@ -1870,6 +1935,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_add_without_optionals() { let instruction = Instruction { off0: 1, @@ -1897,6 +1963,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_mul_non_zero_op1() { let instruction = Instruction { off0: 1, @@ -1929,6 +1996,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_mul_zero_op1() { let instruction = Instruction { off0: 1, @@ -1958,6 +2026,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_op1() { let instruction = Instruction { off0: 1, @@ -1987,6 +2056,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_ret() { let instruction = Instruction { off0: 1, @@ -2017,6 +2087,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_call() { let instruction = Instruction { off0: 1, @@ -2044,6 +2115,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_add_with_optionals() { let instruction = Instruction { off0: 1, @@ -2075,6 +2147,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_add_without_optionals() { let instruction = Instruction { off0: 1, @@ -2101,6 +2174,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_mul_non_zero_op0() { let instruction = Instruction { off0: 1, @@ -2132,6 +2206,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_mul_zero_op0() { let instruction = Instruction { off0: 1, @@ -2161,6 +2236,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_op1_without_dst() { let instruction = Instruction { off0: 1, @@ -2189,6 +2265,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_op1_with_dst() { let instruction = Instruction { off0: 1, @@ -2219,6 +2296,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_op1() { let instruction = Instruction { off0: 1, @@ -2248,6 +2326,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_add() { let instruction = Instruction { off0: 1, @@ -2277,6 +2356,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_mul_int_operands() { let instruction = Instruction { off0: 1, @@ -2306,6 +2386,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_mul_relocatable_values() { let instruction = Instruction { off0: 1, @@ -2333,6 +2414,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_unconstrained() { let instruction = Instruction { off0: 1, @@ -2360,6 +2442,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_assert_eq_with_res() { let instruction = Instruction { off0: 1, @@ -2386,6 +2469,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_assert_eq_without_res() { let instruction = Instruction { off0: 1, @@ -2408,6 +2492,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_call() { let instruction = Instruction { off0: 1, @@ -2433,6 +2518,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_ret() { let instruction = Instruction { off0: 1, @@ -2455,6 +2541,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_add_ap() { let inst = Instruction { off0: 0, @@ -2515,6 +2602,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_mul_fp() { let inst = Instruction { off0: 0, @@ -2574,6 +2662,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_jnz() { let instruction = Instruction { off0: 1, @@ -2627,6 +2716,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_deduce_dst_none() { let instruction = Instruction { off0: 2, @@ -2652,6 +2742,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_res_unconstrained() { let instruction = Instruction { off0: 1, @@ -2682,6 +2773,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_instruction_failed() { let instruction = Instruction { off0: 1, @@ -2718,6 +2810,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_instruction_failed_relocatables() { let instruction = Instruction { off0: 1, @@ -2753,6 +2846,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_inconsistent_op0() { let instruction = Instruction { off0: 1, @@ -2789,6 +2883,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_inconsistent_dst() { let instruction = Instruction { off0: 1, @@ -2824,6 +2919,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /// Test for a simple program execution /// Used program code: /// func main(): @@ -2877,6 +2973,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Test for a simple program execution Used program code: @@ -2991,6 +3088,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /// Test the following program: /// ... /// [ap] = 4 @@ -3101,12 +3199,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_no_pedersen_builtin() { let vm = vm!(); assert_matches!(vm.deduce_memory_cell(Relocatable::from((0, 0))), Ok(None)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_builtin_valid() { let mut vm = vm!(); let builtin = HashBuiltinRunner::new(8, true); @@ -3121,6 +3221,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output pedersen from starkware.cairo.common.cairo_builtins import HashBuiltin @@ -3207,6 +3308,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_builtin_valid_and() { let mut vm = vm!(); let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -3220,6 +3322,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3287,6 +3390,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_builtin_valid() { let mut vm = vm!(); let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -3341,6 +3445,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Data taken from this program execution: %builtins output ec_op from starkware.cairo.common.cairo_builtins import EcOpBuiltin @@ -3405,6 +3510,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_auto_deductions_for_ec_op_builtin_valid_points_invalid_result() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); builtin.base = 3; @@ -3468,6 +3574,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3491,6 +3598,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3520,6 +3628,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output pedersen from starkware.cairo.common.cairo_builtins import HashBuiltin @@ -3553,6 +3662,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn can_get_return_values() { let mut vm = vm!(); vm.set_ap(4); @@ -3567,6 +3677,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_return_values_fails_when_ap_is_0() { let mut vm = vm!(); vm.segments = segments![((1, 0), 1), ((1, 1), 2), ((1, 2), 3), ((1, 3), 4)]; @@ -3595,6 +3706,7 @@ mod tests { */ #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_step_for_preset_memory_with_alloc_hint() { let mut vm = vm!(true); let hint_data_dictionary = HashMap::from([( @@ -3673,6 +3785,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_builtin_runners() { let mut vm = vm!(); let hash_builtin = HashBuiltinRunner::new(8, true); @@ -3689,6 +3802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn disable_trace() { let mut vm = VirtualMachine::new(true); assert!(vm.trace.is_some()); @@ -3697,6 +3811,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -3714,6 +3829,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_non_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -3732,6 +3848,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -3748,6 +3865,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_non_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -3759,6 +3877,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_after_computing_used() { let mut vm = vm!(); vm.segments = segments![ @@ -3775,12 +3894,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_before_computing_used() { let vm = vm!(); assert_eq!(None, vm.get_segment_used_size(2)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_and_set_pc() { let mut vm = vm!(); vm.set_pc(Relocatable { @@ -3797,6 +3918,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_and_set_fp() { let mut vm = vm!(); vm.set_fp(3); @@ -3810,6 +3932,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_key_not_in_memory() { let vm = vm!(); assert_eq!( @@ -3822,12 +3945,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_error() { let vm = vm!(); assert_eq!(vm.get_maybe(&MaybeRelocatable::Int(Felt::new(0_i32))), None,); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_error() { let mut vm = vm!(); let scopes = exec_scopes_ref!(); @@ -3842,6 +3967,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_temporary_segments() { let mut vm = vm!(); let mut _base = vm.add_temporary_segment(); @@ -3863,6 +3989,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_current_instruction_invalid_encoding() { let mut vm = vm!(); vm.segments = segments![((0, 0), ("112233445566778899", 16))]; @@ -3873,6 +4000,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocation_rule_test() { let mut vm = vm!(); @@ -3899,6 +4027,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_relocatable() { let mut vm = vm!(); @@ -3911,6 +4040,7 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and no prime number just /// passes the value through. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint() { let mut vm = vm!(); @@ -3923,6 +4053,7 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and a prime number passes /// the value through after applying the modulo. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint_prime() { let mut vm = vm!(); let prime = felt_str!(felt::PRIME_STR[2..], 16); @@ -3934,6 +4065,7 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec() { let mut vm = vm!(); @@ -3954,6 +4086,7 @@ mod tests { /// Test that compute_effective_sizes() works as intended. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes() { let mut vm = vm!(); @@ -3969,10 +4102,11 @@ mod tests { ) .expect("Could not load data into memory."); - assert_eq!(vm.compute_effective_sizes(), &vec![4]); + assert_eq!(vm.segments.compute_effective_sizes(), &vec![4]); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed() { let mut vm = vm!(); vm.run_finished = true; @@ -4010,6 +4144,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed_run_not_finished() { let mut vm = vm!(); assert_matches!( @@ -4019,6 +4154,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed_missing_accessed_addresses() { let mut vm = vm!(); assert_matches!( @@ -4028,12 +4164,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_entries_bad_usort() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_usort.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -4052,12 +4189,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_entries_bad_dict_update() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_dict_update.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/bad_programs/bad_dict_update.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -4142,8 +4280,8 @@ mod tests { ); #[cfg(feature = "hooks")] { - let program = crate::types::program::Program::from_file( - Path::new("cairo_programs/sqrt.json"), + let program = crate::types::program::Program::from_bytes( + include_bytes!("../../cairo_programs/sqrt.json"), Some("main"), ) .expect("Call to `Program::from_file()` failed."); diff --git a/src/vm/vm_memory/memory.rs b/src/vm/vm_memory/memory.rs index 6f6afe4892..da80a04cc2 100644 --- a/src/vm/vm_memory/memory.rs +++ b/src/vm/vm_memory/memory.rs @@ -1,3 +1,10 @@ +use crate::stdlib::{ + borrow::Cow, + collections::{HashMap, HashSet}, + fmt, + prelude::*, +}; + use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, utils::from_relocatable_to_indexes, @@ -5,11 +12,7 @@ use crate::{ }; use felt::Felt; use num_traits::ToPrimitive; -use std::{ - borrow::Cow, - collections::{HashMap, HashSet}, - fmt::{Display, Formatter}, -}; + pub struct ValidationRule( #[allow(clippy::type_complexity)] pub Box Result, MemoryError>>, @@ -355,8 +358,8 @@ impl Memory { } } -impl Display for Memory { - fn fmt(&self, f: &mut Formatter) -> std::fmt::Result { +impl fmt::Display for Memory { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for (i, segment) in self.temp_data.iter().enumerate() { for (j, cell) in segment.iter().enumerate() { if let Some(cell) = cell { @@ -424,7 +427,7 @@ impl Default for Memory { #[cfg(test)] mod memory_tests { - use std::ops::Shl; + use core::ops::Shl; use super::*; use crate::{ @@ -445,6 +448,9 @@ mod memory_tests { use crate::utils::test_utils::memory_from_memory; use crate::utils::test_utils::memory_inner; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + pub fn memory_from( key_val_list: Vec<(MaybeRelocatable, MaybeRelocatable)>, num_segements: usize, @@ -460,6 +466,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_succesful() { let key = MaybeRelocatable::from((0, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -473,6 +480,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_valuef_from_temp_segment() { let mut memory = Memory::new(); memory.temp_data = vec![vec![ @@ -487,6 +495,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_value_in_temp_segment() { let key = MaybeRelocatable::from((-1, 3)); let val = MaybeRelocatable::from(Felt::new(8)); @@ -500,6 +509,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_succesful() { let key = MaybeRelocatable::from((-1, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -513,6 +523,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_failed() { let key = mayberelocatable!(-1, 1); let mut memory = Memory::new(); @@ -528,6 +539,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_allocated_memory() { let key = MaybeRelocatable::from((0, 0)); let memory = Memory::new(); @@ -535,6 +547,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_existant_element() { let key = MaybeRelocatable::from((0, 0)); let memory = Memory::new(); @@ -542,6 +555,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_relocatable_key() { let key = MaybeRelocatable::from(Felt::new(0)); let memory = Memory::new(); @@ -549,6 +563,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_allocated_memory() { let key = MaybeRelocatable::from((0, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -558,6 +573,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_inconsistent_memory() { let key = MaybeRelocatable::from((0, 0)); let val_a = MaybeRelocatable::from(Felt::new(5)); @@ -575,6 +591,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_address_not_relocatable() { let key = MaybeRelocatable::from(Felt::new(5)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -588,6 +605,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_contiguous_element() { let key_a = MaybeRelocatable::from((0, 0)); let key_b = MaybeRelocatable::from((0, 2)); @@ -600,6 +618,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_contiguous_element_memory_gaps_none() { let key_a = MaybeRelocatable::from((0, 0)); let key_b = MaybeRelocatable::from((0, 5)); @@ -616,6 +635,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_array_test() { let mem = memory_from( vec![( @@ -629,6 +649,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_within_bounds() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -653,6 +674,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_outside_bounds() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -677,6 +699,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_invalid_signature() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut segments = MemorySegmentManager::new(); @@ -703,6 +726,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_valid_signature() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -740,6 +764,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_relocatable_value() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -754,6 +779,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_out_of_bounds_diff_segment() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -772,6 +798,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_valid() { let memory = memory![((0, 0), 10)]; assert_eq!( @@ -784,6 +811,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_invalid_expected_integer() { let mut segments = MemorySegmentManager::new(); segments.add(); @@ -803,12 +831,14 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn default_memory() { let mem: Memory = Default::default(); assert_eq!(mem.data.len(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_temporary_succesful() { let mut memory = Memory::new(); memory.temp_data.push(Vec::new()); @@ -821,6 +851,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocation_rule() { let mut memory = Memory::new(); @@ -847,6 +878,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_bigint() { let mut memory = Memory::new(); memory @@ -864,6 +896,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable() { let mut memory = Memory::new(); memory @@ -885,6 +918,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable_temporary_segment_no_rules() { let mut memory = Memory::new(); memory @@ -903,6 +937,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable_temporary_segment_rules() { let mut memory = Memory::new(); memory @@ -931,7 +966,9 @@ mod memory_tests { Cow::Owned(MaybeRelocatable::RelocatableValue((2, 7).into())), ); } + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -948,6 +985,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_non_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -965,6 +1003,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -980,6 +1019,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_non_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -991,6 +1031,7 @@ mod memory_tests { /// Test that relocate_memory() works when there are no relocation rules. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_empty_relocation_rules() { let mut memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3)]; @@ -999,6 +1040,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_with_gap() { let mut memory = memory![ ((0, 0), 1), @@ -1033,6 +1075,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment() { let mut memory = memory![ ((0, 0), 1), @@ -1068,6 +1111,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_unallocated() { let mut memory = memory![ ((0, 0), 1), @@ -1091,6 +1135,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment() { let mut memory = memory![ ((0, 0), 1), @@ -1125,6 +1170,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment_inconsistent_memory() { let mut memory = memory![ ((0, 0), 1), @@ -1152,6 +1198,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_2_temporary_segments_one_relocated() { let mut memory = memory![ ((0, 0), 1), @@ -1189,6 +1236,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_2_temporary_segments_relocated() { let mut memory = memory![ ((0, 0), 1), @@ -1232,6 +1280,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_memory_display() { let memory = memory![ ((0, 0), 1), @@ -1251,6 +1300,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment_temporary_values_in_temporary_memory() { let mut memory = memory![ ((0, 0), 1), @@ -1284,6 +1334,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_with_rules() { let mut memory = Memory::new(); memory @@ -1304,6 +1355,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_no_rules() { let memory = Memory::new(); assert_eq!( @@ -1317,6 +1369,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_real_addr() { let memory = Memory::new(); assert_eq!( diff --git a/src/vm/vm_memory/memory_segments.rs b/src/vm/vm_memory/memory_segments.rs index 1e59bbfcd6..6bef9c4673 100644 --- a/src/vm/vm_memory/memory_segments.rs +++ b/src/vm/vm_memory/memory_segments.rs @@ -1,4 +1,7 @@ +use crate::stdlib::prelude::*; +use crate::stdlib::{any::Any, collections::HashMap}; use crate::vm::runners::cairo_runner::CairoArg; + use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, vm::{ @@ -6,7 +9,6 @@ use crate::{ vm_memory::memory::Memory, }, }; -use std::{any::Any, collections::HashMap}; pub struct MemorySegmentManager { pub segment_sizes: HashMap, @@ -238,9 +240,12 @@ mod tests { use assert_matches::assert_matches; use felt::Felt; use num_traits::Num; - use std::vec; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_segment_no_size() { let mut segments = MemorySegmentManager::new(); let base = segments.add(); @@ -249,6 +254,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_segment_no_size_test_two_segments() { let mut segments = MemorySegmentManager::new(); let mut _base = segments.add(); @@ -264,6 +270,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_one_temporary_segment() { let mut segments = MemorySegmentManager::new(); let base = segments.add_temporary_segment(); @@ -272,6 +279,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_two_temporary_segments() { let mut segments = MemorySegmentManager::new(); segments.add_temporary_segment(); @@ -287,6 +295,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_empty() { let data = Vec::new(); let ptr = Relocatable::from((0, 3)); @@ -296,6 +305,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_one_element() { let data = vec![MaybeRelocatable::from(Felt::new(4))]; let ptr = Relocatable::from((0, 0)); @@ -310,6 +320,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_three_elements() { let data = vec![ MaybeRelocatable::from(Felt::new(4)), @@ -344,6 +355,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory() { let mut segments = segments![((0, 0), 1), ((0, 1), 1), ((0, 2), 1)]; segments.compute_effective_sizes(); @@ -351,6 +363,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory_with_gap() { let mut segments = MemorySegmentManager::new(); segments.add(); @@ -366,6 +379,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory_with_gaps() { let mut segments = segments![((0, 3), 1), ((0, 4), 1), ((0, 7), 1), ((0, 9), 1)]; segments.compute_effective_sizes(); @@ -373,6 +387,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_three_segment_memory() { let mut segments = segments![ ((0, 0), 1), @@ -390,6 +405,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_three_segment_memory_with_gaps() { let mut segments = segments![ ((0, 2), 1), @@ -405,6 +421,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_after_computing_used() { let mut segments = segments![ ((0, 2), 1), @@ -420,12 +437,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_before_computing_used() { let segments = MemorySegmentManager::new(); assert_eq!(None, segments.get_segment_used_size(2)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_segments_one_segment() { let mut segments = MemorySegmentManager::new(); segments.segment_used_sizes = Some(vec![3]); @@ -438,6 +457,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_segments_five_segment() { let mut segments = MemorySegmentManager::new(); segments.segment_used_sizes = Some(vec![3, 3, 56, 78, 8]); @@ -450,6 +470,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_arg_with_apply_modulo() { let mut big_num = num_bigint::BigInt::from_str_radix(&felt::PRIME_STR[2..], 16) .expect("Couldn't parse prime"); @@ -476,6 +497,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_arg_relocatable() { let data = vec![ Relocatable::from((0, 1)), @@ -502,6 +524,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn segment_default() { let segment_mng_new = MemorySegmentManager::new(); let segment_mng_def: MemorySegmentManager = Default::default(); @@ -516,6 +539,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_missing_effective_sizes() { let segment_manager = MemorySegmentManager::new(); @@ -526,6 +550,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_temporary_segment() { let mut segment_manager = MemorySegmentManager::new(); @@ -537,6 +562,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_invalid_segment() { let mut segment_manager = MemorySegmentManager::new(); @@ -548,6 +574,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value() { let mut segment_manager = MemorySegmentManager::new(); @@ -559,6 +586,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_missing_segment_used_sizes() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.memory = memory![((0, 0), 0)]; @@ -572,6 +600,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_out_of_address_offset_bigger_than_size() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![2]); @@ -590,6 +619,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(Vec::new()); @@ -597,6 +627,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty2() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![4]); @@ -604,6 +635,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![10]); @@ -626,6 +658,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes2() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -650,6 +683,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size_missing_segment() { let memory_segment_manager = MemorySegmentManager::new(); @@ -657,6 +691,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size_used() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![5]); @@ -665,6 +700,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_sizes = HashMap::from([(0, 5)]); @@ -673,6 +709,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size2() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_sizes = HashMap::from([(0, 5)]); @@ -684,6 +721,7 @@ mod tests { /// Test that the call to .gen_arg() with a relocatable just passes the /// value through. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_relocatable() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -696,6 +734,7 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and no prime number just /// passes the value through. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -708,6 +747,7 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -731,6 +771,7 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec_relocatable() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -750,6 +791,7 @@ mod tests { /// Test that the call to .gen_arg() with any other argument returns a not /// implemented error. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_invalid_type() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -760,6 +802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_size_nor_memory_no_change() { let mut segments = MemorySegmentManager::new(); segments.finalize(None, 0, None); @@ -771,6 +814,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_memory() { let mut segments = MemorySegmentManager::new(); segments.finalize(Some(42), 0, None); @@ -779,6 +823,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_size() { let mut segments = MemorySegmentManager::new(); segments.finalize(None, 0, Some(&vec![(1_usize, 2_usize)])); @@ -790,6 +835,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_all_args() { let mut segments = MemorySegmentManager::new(); segments.finalize(Some(42), 0, Some(&vec![(1_usize, 2_usize)])); @@ -801,6 +847,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_single() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -811,6 +858,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_array() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -833,6 +881,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_composed() { let mut memory_segment_manager = MemorySegmentManager::new(); let cairo_args = CairoArg::Composed(vec![ diff --git a/src/with_alloc.rs b/src/with_alloc.rs new file mode 100644 index 0000000000..450af26178 --- /dev/null +++ b/src/with_alloc.rs @@ -0,0 +1,15 @@ +#[macro_use] +pub extern crate alloc; + +pub mod with_alloc { + pub use alloc::borrow; + pub use alloc::boxed; + pub use alloc::rc; + pub use alloc::string; + pub use alloc::sync; + pub use alloc::vec; + + pub mod collections { + pub use hashbrown::{HashMap, HashSet}; + } +} diff --git a/src/with_std.rs b/src/with_std.rs new file mode 100644 index 0000000000..2b30649c4e --- /dev/null +++ b/src/with_std.rs @@ -0,0 +1,34 @@ +// Inspired by Substrate sp-std crate +// see https://github.com/paritytech/substrate/blob/master/primitives/std/with_std.rs + +pub mod with_std { + pub use core::time; + pub use std::alloc; + pub use std::any; + pub use std::borrow; + pub use std::boxed; + pub use std::cell; + pub use std::clone; + pub use std::cmp; + pub use std::convert; + pub use std::default; + pub use std::fmt; + pub use std::hash; + pub use std::iter; + pub use std::marker; + pub use std::mem; + pub use std::num; + pub use std::ops; + pub use std::ptr; + pub use std::rc; + pub use std::result; + pub use std::slice; + pub use std::str; + pub use std::string; + pub use std::sync; + pub use std::vec; + + pub mod collections { + pub use std::collections::{HashMap, HashSet}; + } +} diff --git a/src/without_std.rs b/src/without_std.rs new file mode 100644 index 0000000000..1fb0b9746c --- /dev/null +++ b/src/without_std.rs @@ -0,0 +1,24 @@ +// Inspired by Substrate sp-std crate +// see https://github.com/paritytech/substrate/blob/master/primitives/std/without_std.rs + +pub mod without_std { + pub use core::any; + pub use core::borrow; + pub use core::cell; + pub use core::clone; + pub use core::cmp; + pub use core::convert; + pub use core::default; + pub use core::fmt; + pub use core::hash; + pub use core::iter; + pub use core::marker; + pub use core::mem; + pub use core::num; + pub use core::ops; + pub use core::ptr; + pub use core::result; + pub use core::slice; + pub use core::str; + pub use core::time; +} diff --git a/tests/cairo_run_test.rs b/tests/cairo_run_test.rs index d4b7bd88aa..c1bbb9f0a7 100644 --- a/tests/cairo_run_test.rs +++ b/tests/cairo_run_test.rs @@ -1,8 +1,11 @@ use cairo_vm::cairo_run; use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; -use std::path::Path; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -10,7 +13,7 @@ fn cairo_run_test() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/fibonacci.json"), + include_bytes!("../cairo_programs/fibonacci.json"), &cairo_run_config, &mut hint_executor, ) @@ -18,6 +21,7 @@ fn cairo_run_test() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_array_sum() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -25,7 +29,7 @@ fn cairo_run_array_sum() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/array_sum.json"), + include_bytes!("../cairo_programs/array_sum.json"), &cairo_run_config, &mut hint_executor, ) @@ -33,6 +37,7 @@ fn cairo_run_array_sum() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_big_struct() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -40,7 +45,7 @@ fn cairo_run_big_struct() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/big_struct.json"), + include_bytes!("../cairo_programs/big_struct.json"), &cairo_run_config, &mut hint_executor, ) @@ -48,6 +53,7 @@ fn cairo_run_big_struct() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_call_function_assign_param_by_name() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -55,7 +61,7 @@ fn cairo_run_call_function_assign_param_by_name() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/call_function_assign_param_by_name.json"), + include_bytes!("../cairo_programs/call_function_assign_param_by_name.json"), &cairo_run_config, &mut hint_executor, ) @@ -63,6 +69,7 @@ fn cairo_run_call_function_assign_param_by_name() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -70,7 +77,7 @@ fn cairo_run_function_return() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/function_return.json"), + include_bytes!("../cairo_programs/function_return.json"), &cairo_run_config, &mut hint_executor, ) @@ -78,6 +85,7 @@ fn cairo_run_function_return() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return_if_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -85,7 +93,7 @@ fn cairo_run_function_return_if_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/function_return_if_print.json"), + include_bytes!("../cairo_programs/function_return_if_print.json"), &cairo_run_config, &mut hint_executor, ) @@ -93,6 +101,7 @@ fn cairo_run_function_return_if_print() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return_to_variable() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -100,7 +109,7 @@ fn cairo_run_function_return_to_variable() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/function_return_to_variable.json"), + include_bytes!("../cairo_programs/function_return_to_variable.json"), &cairo_run_config, &mut hint_executor, ) @@ -108,6 +117,7 @@ fn cairo_run_function_return_to_variable() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_and_prime() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -115,7 +125,7 @@ fn cairo_run_if_and_prime() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/if_and_prime.json"), + include_bytes!("../cairo_programs/if_and_prime.json"), &cairo_run_config, &mut hint_executor, ) @@ -123,6 +133,7 @@ fn cairo_run_if_and_prime() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_in_function() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -130,7 +141,7 @@ fn cairo_run_if_in_function() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/if_in_function.json"), + include_bytes!("../cairo_programs/if_in_function.json"), &cairo_run_config, &mut hint_executor, ) @@ -138,6 +149,7 @@ fn cairo_run_if_in_function() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_list() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -145,7 +157,7 @@ fn cairo_run_if_list() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/if_list.json"), + include_bytes!("../cairo_programs/if_list.json"), &cairo_run_config, &mut hint_executor, ) @@ -153,6 +165,7 @@ fn cairo_run_if_list() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_jmp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -160,7 +173,7 @@ fn cairo_run_jmp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/jmp.json"), + include_bytes!("../cairo_programs/jmp.json"), &cairo_run_config, &mut hint_executor, ) @@ -168,6 +181,7 @@ fn cairo_run_jmp() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_jmp_if_condition() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -175,7 +189,7 @@ fn cairo_run_jmp_if_condition() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/jmp_if_condition.json"), + include_bytes!("../cairo_programs/jmp_if_condition.json"), &cairo_run_config, &mut hint_executor, ) @@ -183,6 +197,7 @@ fn cairo_run_jmp_if_condition() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_pointers() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -190,7 +205,7 @@ fn cairo_run_pointers() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/pointers.json"), + include_bytes!("../cairo_programs/pointers.json"), &cairo_run_config, &mut hint_executor, ) @@ -198,6 +213,7 @@ fn cairo_run_pointers() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -205,7 +221,7 @@ fn cairo_run_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/print.json"), + include_bytes!("../cairo_programs/print.json"), &cairo_run_config, &mut hint_executor, ) @@ -213,6 +229,7 @@ fn cairo_run_print() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_return() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -220,7 +237,7 @@ fn cairo_run_return() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/return.json"), + include_bytes!("../cairo_programs/return.json"), &cairo_run_config, &mut hint_executor, ) @@ -228,6 +245,7 @@ fn cairo_run_return() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_reversed_register_instructions() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -235,7 +253,7 @@ fn cairo_run_reversed_register_instructions() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/reversed_register_instructions.json"), + include_bytes!("../cairo_programs/reversed_register_instructions.json"), &cairo_run_config, &mut hint_executor, ) @@ -243,6 +261,7 @@ fn cairo_run_reversed_register_instructions() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_simple_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -250,7 +269,7 @@ fn cairo_run_simple_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/simple_print.json"), + include_bytes!("../cairo_programs/simple_print.json"), &cairo_run_config, &mut hint_executor, ) @@ -258,6 +277,7 @@ fn cairo_run_simple_print() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_addition_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -265,7 +285,7 @@ fn cairo_run_test_addition_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/test_addition_if.json"), + include_bytes!("../cairo_programs/test_addition_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -273,6 +293,7 @@ fn cairo_run_test_addition_if() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_reverse_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -280,7 +301,7 @@ fn cairo_run_test_reverse_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/test_reverse_if.json"), + include_bytes!("../cairo_programs/test_reverse_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -288,6 +309,7 @@ fn cairo_run_test_reverse_if() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_subtraction_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -295,7 +317,7 @@ fn cairo_run_test_subtraction_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/test_subtraction_if.json"), + include_bytes!("../cairo_programs/test_subtraction_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -303,6 +325,7 @@ fn cairo_run_test_subtraction_if() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_use_imported_module() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -310,7 +333,7 @@ fn cairo_run_use_imported_module() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/use_imported_module.json"), + include_bytes!("../cairo_programs/use_imported_module.json"), &cairo_run_config, &mut hint_executor, ) @@ -318,6 +341,7 @@ fn cairo_run_use_imported_module() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_bitwise_output() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -325,7 +349,7 @@ fn cairo_run_bitwise_output() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/bitwise_output.json"), + include_bytes!("../cairo_programs/bitwise_output.json"), &cairo_run_config, &mut hint_executor, ) @@ -333,6 +357,7 @@ fn cairo_run_bitwise_output() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_bitwise_recursion() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -340,7 +365,7 @@ fn cairo_run_bitwise_recursion() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/bitwise_recursion.json"), + include_bytes!("../cairo_programs/bitwise_recursion.json"), &cairo_run_config, &mut hint_executor, ) @@ -348,6 +373,7 @@ fn cairo_run_bitwise_recursion() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -355,7 +381,7 @@ fn cairo_run_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/integration.json"), + include_bytes!("../cairo_programs/integration.json"), &cairo_run_config, &mut hint_executor, ) @@ -363,6 +389,7 @@ fn cairo_run_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_integration_with_alloc_locals() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -370,7 +397,7 @@ fn cairo_run_integration_with_alloc_locals() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/integration_with_alloc_locals.json"), + include_bytes!("../cairo_programs/integration_with_alloc_locals.json"), &cairo_run_config, &mut hint_executor, ) @@ -378,6 +405,7 @@ fn cairo_run_integration_with_alloc_locals() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_arrays() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -385,7 +413,7 @@ fn cairo_run_compare_arrays() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/compare_arrays.json"), + include_bytes!("../cairo_programs/compare_arrays.json"), &cairo_run_config, &mut hint_executor, ) @@ -393,6 +421,7 @@ fn cairo_run_compare_arrays() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_greater_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -400,7 +429,7 @@ fn cairo_run_compare_greater_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/compare_greater_array.json"), + include_bytes!("../cairo_programs/compare_greater_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -408,6 +437,7 @@ fn cairo_run_compare_greater_array() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_lesser_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -415,7 +445,7 @@ fn cairo_run_compare_lesser_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/compare_lesser_array.json"), + include_bytes!("../cairo_programs/compare_lesser_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -423,6 +453,7 @@ fn cairo_run_compare_lesser_array() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_le_felt_hint() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -430,7 +461,7 @@ fn cairo_run_assert_le_felt_hint() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_le_felt_hint.json"), + include_bytes!("../cairo_programs/assert_le_felt_hint.json"), &cairo_run_config, &mut hint_executor, ) @@ -438,6 +469,7 @@ fn cairo_run_assert_le_felt_hint() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_250_bit_element_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -445,7 +477,7 @@ fn cairo_run_assert_250_bit_element_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_250_bit_element_array.json"), + include_bytes!("../cairo_programs/assert_250_bit_element_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -453,6 +485,7 @@ fn cairo_run_assert_250_bit_element_array() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_abs_value() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -460,7 +493,7 @@ fn cairo_abs_value() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/abs_value_array.json"), + include_bytes!("../cairo_programs/abs_value_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -468,6 +501,7 @@ fn cairo_abs_value() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_different_arrays() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -475,7 +509,7 @@ fn cairo_run_compare_different_arrays() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/compare_different_arrays.json"), + include_bytes!("../cairo_programs/compare_different_arrays.json"), &cairo_run_config, &mut hint_executor, ) @@ -483,6 +517,7 @@ fn cairo_run_compare_different_arrays() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_nn() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -490,7 +525,7 @@ fn cairo_run_assert_nn() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_nn.json"), + include_bytes!("../cairo_programs/assert_nn.json"), &cairo_run_config, &mut hint_executor, ) @@ -498,6 +533,7 @@ fn cairo_run_assert_nn() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_sqrt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -505,7 +541,7 @@ fn cairo_run_sqrt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/sqrt.json"), + include_bytes!("../cairo_programs/sqrt.json"), &cairo_run_config, &mut hint_executor, ) @@ -513,6 +549,7 @@ fn cairo_run_sqrt() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_not_zero() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -520,7 +557,7 @@ fn cairo_run_assert_not_zero() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_not_zero.json"), + include_bytes!("../cairo_programs/assert_not_zero.json"), &cairo_run_config, &mut hint_executor, ) @@ -528,6 +565,7 @@ fn cairo_run_assert_not_zero() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_int() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -535,7 +573,7 @@ fn cairo_run_split_int() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/split_int.json"), + include_bytes!("../cairo_programs/split_int.json"), &cairo_run_config, &mut hint_executor, ) @@ -543,6 +581,7 @@ fn cairo_run_split_int() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_int_big() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -550,7 +589,7 @@ fn cairo_run_split_int_big() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/split_int_big.json"), + include_bytes!("../cairo_programs/split_int_big.json"), &cairo_run_config, &mut hint_executor, ) @@ -558,6 +597,7 @@ fn cairo_run_split_int_big() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_felt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -565,7 +605,7 @@ fn cairo_run_split_felt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/split_felt.json"), + include_bytes!("../cairo_programs/split_felt.json"), &cairo_run_config, &mut hint_executor, ) @@ -573,6 +613,7 @@ fn cairo_run_split_felt() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_math_cmp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -580,7 +621,7 @@ fn cairo_run_math_cmp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/math_cmp.json"), + include_bytes!("../cairo_programs/math_cmp.json"), &cairo_run_config, &mut hint_executor, ) @@ -588,6 +629,7 @@ fn cairo_run_math_cmp() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsigned_div_rem() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -595,7 +637,7 @@ fn cairo_run_unsigned_div_rem() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/unsigned_div_rem.json"), + include_bytes!("../cairo_programs/unsigned_div_rem.json"), &cairo_run_config, &mut hint_executor, ) @@ -603,6 +645,7 @@ fn cairo_run_unsigned_div_rem() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_signed_div_rem() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -610,7 +653,7 @@ fn cairo_run_signed_div_rem() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/signed_div_rem.json"), + include_bytes!("../cairo_programs/signed_div_rem.json"), &cairo_run_config, &mut hint_executor, ) @@ -618,6 +661,7 @@ fn cairo_run_signed_div_rem() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_lt_felt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -625,7 +669,7 @@ fn cairo_run_assert_lt_felt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_lt_felt.json"), + include_bytes!("../cairo_programs/assert_lt_felt.json"), &cairo_run_config, &mut hint_executor, ) @@ -633,6 +677,7 @@ fn cairo_run_assert_lt_felt() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memcpy() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -640,7 +685,7 @@ fn cairo_run_memcpy() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/memcpy_test.json"), + include_bytes!("../cairo_programs/memcpy_test.json"), &cairo_run_config, &mut hint_executor, ) @@ -648,6 +693,7 @@ fn cairo_run_memcpy() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memset() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -655,7 +701,7 @@ fn cairo_run_memset() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/memset.json"), + include_bytes!("../cairo_programs/memset.json"), &cairo_run_config, &mut hint_executor, ) @@ -663,6 +709,7 @@ fn cairo_run_memset() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_pow() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -670,7 +717,7 @@ fn cairo_run_pow() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/pow.json"), + include_bytes!("../cairo_programs/pow.json"), &cairo_run_config, &mut hint_executor, ) @@ -678,6 +725,7 @@ fn cairo_run_pow() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -685,7 +733,7 @@ fn cairo_run_dict() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict.json"), + include_bytes!("../cairo_programs/dict.json"), &cairo_run_config, &mut hint_executor, ) @@ -693,6 +741,7 @@ fn cairo_run_dict() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_update() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -700,7 +749,7 @@ fn cairo_run_dict_update() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict_update.json"), + include_bytes!("../cairo_programs/dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -708,6 +757,7 @@ fn cairo_run_dict_update() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_uint256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -715,7 +765,7 @@ fn cairo_run_uint256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/uint256.json"), + include_bytes!("../cairo_programs/uint256.json"), &cairo_run_config, &mut hint_executor, ) @@ -723,6 +773,7 @@ fn cairo_run_uint256() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_find_element() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -730,7 +781,7 @@ fn cairo_run_find_element() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/find_element.json"), + include_bytes!("../cairo_programs/find_element.json"), &cairo_run_config, &mut hint_executor, ) @@ -738,6 +789,7 @@ fn cairo_run_find_element() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_search_sorted_lower() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -745,7 +797,7 @@ fn cairo_run_search_sorted_lower() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/search_sorted_lower.json"), + include_bytes!("../cairo_programs/search_sorted_lower.json"), &cairo_run_config, &mut hint_executor, ) @@ -753,6 +805,7 @@ fn cairo_run_search_sorted_lower() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_usort() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -760,7 +813,7 @@ fn cairo_run_usort() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/usort.json"), + include_bytes!("../cairo_programs/usort.json"), &cairo_run_config, &mut hint_executor, ) @@ -768,6 +821,7 @@ fn cairo_run_usort() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_usort_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -775,7 +829,7 @@ fn cairo_run_usort_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_usort.json"), + include_bytes!("../cairo_programs/bad_programs/bad_usort.json"), &cairo_run_config, &mut hint_executor, ); @@ -788,6 +842,7 @@ fn cairo_run_usort_bad() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_write_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -795,7 +850,7 @@ fn cairo_run_dict_write_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; assert!(cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_dict_new.json"), + include_bytes!("../cairo_programs/bad_programs/bad_dict_new.json"), &cairo_run_config, &mut hint_executor, ) @@ -806,7 +861,7 @@ fn cairo_run_dict_write_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_dict_new.json"), + include_bytes!("../cairo_programs/bad_programs/bad_dict_new.json"), &cairo_run_config, &mut hint_executor, ) @@ -818,6 +873,7 @@ fn cairo_run_dict_write_bad() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_update_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -825,7 +881,7 @@ fn cairo_run_dict_update_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; assert!(cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_dict_update.json"), + include_bytes!("../cairo_programs/bad_programs/bad_dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -836,7 +892,7 @@ fn cairo_run_dict_update_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_dict_update.json"), + include_bytes!("../cairo_programs/bad_programs/bad_dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -847,6 +903,7 @@ fn cairo_run_dict_update_bad() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_squash_dict() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -854,7 +911,7 @@ fn cairo_run_squash_dict() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/squash_dict.json"), + include_bytes!("../cairo_programs/squash_dict.json"), &cairo_run_config, &mut hint_executor, ) @@ -862,6 +919,7 @@ fn cairo_run_squash_dict() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_squash() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -869,7 +927,7 @@ fn cairo_run_dict_squash() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict_squash.json"), + include_bytes!("../cairo_programs/dict_squash.json"), &cairo_run_config, &mut hint_executor, ) @@ -877,6 +935,7 @@ fn cairo_run_dict_squash() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_set_add() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -884,7 +943,7 @@ fn cairo_run_set_add() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/set_add.json"), + include_bytes!("../cairo_programs/set_add.json"), &cairo_run_config, &mut hint_executor, ) @@ -892,6 +951,7 @@ fn cairo_run_set_add() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -899,7 +959,7 @@ fn cairo_run_secp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/secp.json"), + include_bytes!("../cairo_programs/secp.json"), &cairo_run_config, &mut hint_executor, ) @@ -907,6 +967,7 @@ fn cairo_run_secp() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_signature() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -914,7 +975,7 @@ fn cairo_run_signature() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/signature.json"), + include_bytes!("../cairo_programs/signature.json"), &cairo_run_config, &mut hint_executor, ) @@ -922,6 +983,7 @@ fn cairo_run_signature() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp_ec() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -929,7 +991,7 @@ fn cairo_run_secp_ec() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/secp_ec.json"), + include_bytes!("../cairo_programs/secp_ec.json"), &cairo_run_config, &mut hint_executor, ) @@ -937,6 +999,7 @@ fn cairo_run_secp_ec() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_hello_world_hash() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -944,7 +1007,7 @@ fn cairo_run_blake2s_hello_world_hash() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/blake2s_hello_world_hash.json"), + include_bytes!("../cairo_programs/blake2s_hello_world_hash.json"), &cairo_run_config, &mut hint_executor, ) @@ -952,6 +1015,7 @@ fn cairo_run_blake2s_hello_world_hash() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_finalize_blake2s() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -959,13 +1023,14 @@ fn cairo_run_finalize_blake2s() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/finalize_blake2s.json"), + include_bytes!("../cairo_programs/finalize_blake2s.json"), &cairo_run_config, &mut hint_executor, ) .expect("Couldn't run program"); } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsafe_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -973,7 +1038,7 @@ fn cairo_run_unsafe_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/unsafe_keccak.json"), + include_bytes!("../cairo_programs/unsafe_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -981,6 +1046,7 @@ fn cairo_run_unsafe_keccak() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_felts() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -988,7 +1054,7 @@ fn cairo_run_blake2s_felts() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/blake2s_felts.json"), + include_bytes!("../cairo_programs/blake2s_felts.json"), &cairo_run_config, &mut hint_executor, ) @@ -996,6 +1062,7 @@ fn cairo_run_blake2s_felts() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsafe_keccak_finalize() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1003,7 +1070,7 @@ fn cairo_run_unsafe_keccak_finalize() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/unsafe_keccak_finalize.json"), + include_bytes!("../cairo_programs/unsafe_keccak_finalize.json"), &cairo_run_config, &mut hint_executor, ) @@ -1011,6 +1078,7 @@ fn cairo_run_unsafe_keccak_finalize() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_add_uint256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1018,7 +1086,7 @@ fn cairo_run_keccak_add_uint256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/keccak_add_uint256.json"), + include_bytes!("../cairo_programs/keccak_add_uint256.json"), &cairo_run_config, &mut hint_executor, ) @@ -1026,6 +1094,7 @@ fn cairo_run_keccak_add_uint256() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_private_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1033,7 +1102,7 @@ fn cairo_run_private_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/_keccak.json"), + include_bytes!("../cairo_programs/_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -1041,6 +1110,7 @@ fn cairo_run_private_keccak() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_copy_inputs() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1048,7 +1118,7 @@ fn cairo_run_keccak_copy_inputs() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/keccak_copy_inputs.json"), + include_bytes!("../cairo_programs/keccak_copy_inputs.json"), &cairo_run_config, &mut hint_executor, ) @@ -1056,6 +1126,7 @@ fn cairo_run_keccak_copy_inputs() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_finalize_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1063,7 +1134,7 @@ fn cairo_run_finalize_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/cairo_finalize_keccak.json"), + include_bytes!("../cairo_programs/cairo_finalize_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -1071,6 +1142,7 @@ fn cairo_run_finalize_keccak() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_operations_with_data() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1078,7 +1150,7 @@ fn cairo_run_operations_with_data() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/operations_with_data_structures.json"), + include_bytes!("../cairo_programs/operations_with_data_structures.json"), &cairo_run_config, &mut hint_executor, ) @@ -1086,6 +1158,7 @@ fn cairo_run_operations_with_data() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_sha256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1093,7 +1166,7 @@ fn cairo_run_sha256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/sha256.json"), + include_bytes!("../cairo_programs/sha256.json"), &cairo_run_config, &mut hint_executor, ) @@ -1101,6 +1174,7 @@ fn cairo_run_sha256() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_math_cmp_and_pow_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1108,7 +1182,7 @@ fn cairo_run_math_cmp_and_pow_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/math_cmp_and_pow_integration_tests.json"), + include_bytes!("../cairo_programs/math_cmp_and_pow_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1116,6 +1190,7 @@ fn cairo_run_math_cmp_and_pow_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_uint256_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1123,7 +1198,7 @@ fn cairo_run_uint256_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/uint256_integration_tests.json"), + include_bytes!("../cairo_programs/uint256_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1131,6 +1206,7 @@ fn cairo_run_uint256_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_set_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1138,7 +1214,7 @@ fn cairo_run_set_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/set_integration_tests.json"), + include_bytes!("../cairo_programs/set_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1146,6 +1222,7 @@ fn cairo_run_set_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memory_module_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1153,7 +1230,7 @@ fn cairo_run_memory_module_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/memory_integration_tests.json"), + include_bytes!("../cairo_programs/memory_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1161,6 +1238,7 @@ fn cairo_run_memory_module_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1168,7 +1246,7 @@ fn cairo_run_dict_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict_integration_tests.json"), + include_bytes!("../cairo_programs/dict_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1176,6 +1254,7 @@ fn cairo_run_dict_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1183,7 +1262,7 @@ fn cairo_run_secp_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/secp_integration_tests.json"), + include_bytes!("../cairo_programs/secp_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1191,6 +1270,7 @@ fn cairo_run_secp_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1198,7 +1278,7 @@ fn cairo_run_keccak_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/keccak_integration_tests.json"), + include_bytes!("../cairo_programs/keccak_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1206,6 +1286,7 @@ fn cairo_run_keccak_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1213,7 +1294,7 @@ fn cairo_run_blake2s_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/blake2s_integration_tests.json"), + include_bytes!("../cairo_programs/blake2s_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1221,6 +1302,7 @@ fn cairo_run_blake2s_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_relocate_segments() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1228,7 +1310,7 @@ fn cairo_run_relocate_segments() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/relocate_segments.json"), + include_bytes!("../cairo_programs/relocate_segments.json"), &cairo_run_config, &mut hint_executor, ) @@ -1236,6 +1318,7 @@ fn cairo_run_relocate_segments() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1243,7 +1326,7 @@ fn cairo_run_error_msg_attr() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/error_msg_attr.json"), + include_bytes!("../cairo_programs/bad_programs/error_msg_attr.json"), &cairo_run_config, &mut hint_executor, ) @@ -1254,6 +1337,7 @@ fn cairo_run_error_msg_attr() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr_ap_based_reference() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1261,17 +1345,22 @@ fn cairo_run_error_msg_attr_ap_based_reference() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + include_bytes!("../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), &cairo_run_config, &mut hint_executor, ) .err() .unwrap(); + #[cfg(feature = "std")] assert_eq!(err.to_string(), String::from("Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n assert x = 2;\n ^***********^\n")); + + #[cfg(not(feature = "std"))] + assert_eq!(err.to_string(), String::from("Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n")); } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr_complex_reference() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1279,7 +1368,7 @@ fn cairo_run_error_msg_attr_complex_reference() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), + include_bytes!("../cairo_programs/bad_programs/error_msg_attr_struct.json"), &cairo_run_config, &mut hint_executor, ) @@ -1289,6 +1378,7 @@ fn cairo_run_error_msg_attr_complex_reference() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_store_cast_pointer() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1296,7 +1386,7 @@ fn cairo_run_dict_store_cast_pointer() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict_store_cast_ptr.json"), + include_bytes!("../cairo_programs/dict_store_cast_ptr.json"), &cairo_run_config, &mut hint_executor, ) @@ -1304,6 +1394,7 @@ fn cairo_run_dict_store_cast_pointer() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_verify_signature_hint() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1311,7 +1402,7 @@ fn cairo_run_verify_signature_hint() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/common_signature.json"), + include_bytes!("../cairo_programs/common_signature.json"), &cairo_run_config, &mut hint_executor, ) From 17f467cc14b2a8be2de0062c7bcdff73b1760e11 Mon Sep 17 00:00:00 2001 From: Juan Rigada <62958725+Jrigada@users.noreply.github.com> Date: Thu, 9 Mar 2023 14:40:59 -0300 Subject: [PATCH 02/15] Expose compute effective sizes from the vm (#887) * expose compute effective sizes * expose compute effective sizes --- src/vm/vm_core.rs | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/src/vm/vm_core.rs b/src/vm/vm_core.rs index 30677aa49e..72daf227bd 100644 --- a/src/vm/vm_core.rs +++ b/src/vm/vm_core.rs @@ -134,6 +134,10 @@ impl VirtualMachine { } } + pub fn compute_segments_effective_sizes(&mut self) { + self.segments.compute_effective_sizes(); + } + ///Returns the encoded instruction (the value at pc) and the immediate value (the value at pc + 1, if it exists in the memory). fn get_instruction_encoding( &self, @@ -4105,6 +4109,27 @@ mod tests { assert_eq!(vm.segments.compute_effective_sizes(), &vec![4]); } + /// Test that compute_segment_effective_sizes() works as intended. + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] + fn compute_segment_effective_sizes() { + let mut vm = vm!(); + + let segment = vm.segments.add(); + vm.load_data( + segment, + &vec![ + mayberelocatable!(1), + mayberelocatable!(2), + mayberelocatable!(3), + mayberelocatable!(4), + ], + ) + .expect("Could not load data into memory."); + + assert_eq!(vm.segments.compute_effective_sizes(), &vec![4]); + } + #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed() { From 23d941fd587354ea6ea82efd397baeed5c4f24bf Mon Sep 17 00:00:00 2001 From: Juan Rigada <62958725+Jrigada@users.noreply.github.com> Date: Fri, 10 Mar 2023 10:38:28 -0300 Subject: [PATCH 03/15] Revert "Wasm32 support (#828)" (#891) This reverts commit c326ba8c63dc36f16e99524e4489b76891b41c96. --- .github/workflows/rust.yml | 8 - Cargo.lock | 325 ++-- Cargo.toml | 102 +- Makefile | 22 +- bench/criterion_benchmark.rs | 3 +- bench/iai_benchmark.rs | 10 +- bench/run_benchmarks.sh | 2 +- cairo-vm-cli/Cargo.toml | 11 - deps/parse-hyperlinks/Cargo.toml | 10 +- deps/parse-hyperlinks/src/lib.rs | 5 - felt/Cargo.toml | 19 +- felt/src/bigint_felt.rs | 35 +- felt/src/lib.rs | 56 +- src/cairo_run.rs | 240 +-- .../builtin_hint_processor/blake2s_hash.rs | 12 +- .../builtin_hint_processor/blake2s_utils.rs | 19 +- .../builtin_hint_processor_definition.rs | 28 +- .../cairo_keccak/keccak_hints.rs | 16 +- .../builtin_hint_processor/dict_hint_utils.rs | 36 +- .../builtin_hint_processor/dict_manager.rs | 16 +- .../find_element_hint.rs | 35 +- .../builtin_hint_processor/hint_utils.rs | 17 +- .../builtin_hint_processor/keccak_utils.rs | 3 +- .../builtin_hint_processor/math_utils.rs | 85 +- .../memcpy_hint_utils.rs | 8 +- .../builtin_hint_processor/memset_utils.rs | 13 +- .../builtin_hint_processor/pow_utils.rs | 12 +- .../secp/bigint_utils.rs | 12 +- .../builtin_hint_processor/secp/ec_utils.rs | 22 +- .../secp/field_utils.rs | 21 +- .../builtin_hint_processor/secp/secp_utils.rs | 12 +- .../builtin_hint_processor/secp/signature.rs | 20 +- .../builtin_hint_processor/segments.rs | 9 +- .../builtin_hint_processor/set.rs | 12 +- .../builtin_hint_processor/sha256_utils.rs | 9 +- .../builtin_hint_processor/signature.rs | 8 +- .../squash_dict_utils.rs | 70 +- .../builtin_hint_processor/uint256_utils.rs | 26 +- .../builtin_hint_processor/usort.rs | 10 +- .../hint_processor_definition.rs | 4 +- src/hint_processor/hint_processor_utils.rs | 20 +- src/lib.rs | 49 - {cairo-vm-cli/src => src}/main.rs | 90 +- src/math_utils.rs | 27 +- src/serde/deserialize_program.rs | 99 +- src/serde/deserialize_utils.rs | 33 +- src/tests/cairo_run_test.rs | 1402 ----------------- src/tests/mod.rs | 7 - src/types/errors/math_errors.rs | 4 - src/types/errors/program_errors.rs | 16 +- src/types/exec_scope.rs | 18 +- .../bitwise_instance_def.rs | 7 - .../builtins_instance_def.rs | 10 - .../instance_definitions/cpu_instance_def.rs | 4 - .../diluted_pool_instance_def.rs | 5 - .../ec_op_instance_def.rs | 7 - .../ecdsa_instance_def.rs | 7 - .../keccak_instance_def.rs | 9 - .../pedersen_instance_def.rs | 7 - .../range_check_instance_def.rs | 7 - src/types/instruction.rs | 6 - src/types/layout.rs | 12 - src/types/program.rs | 60 +- src/types/relocatable.rs | 53 +- src/utils.rs | 81 +- src/vm/context/run_context.rs | 15 - src/vm/decoding/decoder.rs | 16 - src/vm/errors/cairo_run_errors.rs | 6 +- src/vm/errors/exec_scope_errors.rs | 3 - src/vm/errors/hint_errors.rs | 8 +- src/vm/errors/memory_errors.rs | 8 +- src/vm/errors/runner_errors.rs | 10 +- src/vm/errors/trace_errors.rs | 6 +- src/vm/errors/vm_errors.rs | 13 +- src/vm/errors/vm_exception.rs | 179 +-- src/vm/hooks.rs | 25 +- src/vm/runners/builtin_runner/bitwise.rs | 31 +- src/vm/runners/builtin_runner/ec_op.rs | 118 +- src/vm/runners/builtin_runner/hash.rs | 25 +- src/vm/runners/builtin_runner/keccak.rs | 39 +- src/vm/runners/builtin_runner/mod.rs | 79 - src/vm/runners/builtin_runner/output.rs | 26 +- src/vm/runners/builtin_runner/range_check.rs | 38 +- src/vm/runners/builtin_runner/signature.rs | 32 +- src/vm/runners/cairo_runner.rs | 269 ++-- src/vm/security.rs | 15 +- src/vm/trace/mod.rs | 8 +- src/vm/trace/trace_entry.rs | 8 - src/vm/vm_core.rs | 172 +- src/vm/vm_memory/memory.rs | 69 +- src/vm/vm_memory/memory_segments.rs | 53 +- src/with_alloc.rs | 15 - src/with_std.rs | 34 - src/without_std.rs | 24 - {src/tests => tests}/bitwise_test.rs | 18 +- tests/cairo_run_test.rs | 267 ++-- {src/tests => tests}/compare_vm_state.sh | 0 {src/tests => tests}/memory_comparator.py | 0 {src/tests => tests}/pedersen_test.rs | 20 +- {src/tests => tests}/skip_instruction_test.rs | 21 +- {src/tests => tests}/struct_test.rs | 24 +- 101 files changed, 898 insertions(+), 4219 deletions(-) delete mode 100644 cairo-vm-cli/Cargo.toml rename {cairo-vm-cli/src => src}/main.rs (54%) delete mode 100644 src/tests/cairo_run_test.rs delete mode 100644 src/tests/mod.rs delete mode 100644 src/with_alloc.rs delete mode 100644 src/with_std.rs delete mode 100644 src/without_std.rs rename {src/tests => tests}/bitwise_test.rs (94%) rename {src/tests => tests}/compare_vm_state.sh (100%) rename {src/tests => tests}/memory_comparator.py (100%) rename {src/tests => tests}/pedersen_test.rs (87%) rename {src/tests => tests}/skip_instruction_test.rs (61%) rename {src/tests => tests}/struct_test.rs (63%) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 49d668e8c2..48e96fe5c8 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -28,10 +28,6 @@ jobs: uses: taiki-e/install-action@nextest - name: Install cargo-llvm-cov uses: taiki-e/install-action@cargo-llvm-cov - - name: Install wasm-bindgen-cli - uses: jetli/wasm-pack-action@v0.4.0 - with: - version: "v0.10.3" - name: Set up cargo cache uses: Swatinem/rust-cache@v2 @@ -66,10 +62,6 @@ jobs: run: pip install ecdsa fastecdsa sympy cairo-lang - name: Run tests run: make -j test - - name: Run tests no_std - run: make -j test-no_std - - name: Run wasm tests - run: make -j test-wasm - name: Compare trace and memory run: make -j compare_trace_memory - name: Compare trace and memory with proof mode diff --git a/Cargo.lock b/Cargo.lock index a28f8f71cc..dabc670b47 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,23 +2,6 @@ # It is not intended for manual editing. version = 3 -[[package]] -name = "ahash" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f" -dependencies = [ - "cfg-if", - "once_cell", - "version_check", -] - -[[package]] -name = "anyhow" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800" - [[package]] name = "ark-ff" version = "0.3.0" @@ -103,20 +86,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" [[package]] -name = "bincode" -version = "2.0.0-rc.2" -source = "git+https://github.com/bincode-org/bincode.git?tag=v2.0.0-rc.2#6c219e9214bda2bdce1327db6ed7f66d2fa4bf02" +name = "bigdecimal" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6aaf33151a6429fe9211d1b276eafdf70cdff28b071e76c0b0e1503221ea3744" dependencies = [ - "bincode_derive", - "serde", + "num-bigint", + "num-integer", + "num-traits", ] [[package]] -name = "bincode_derive" -version = "2.0.0-rc.2" -source = "git+https://github.com/bincode-org/bincode.git?tag=v2.0.0-rc.2#6c219e9214bda2bdce1327db6ed7f66d2fa4bf02" +name = "bincode" +version = "1.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" dependencies = [ - "virtue", + "serde", ] [[package]] @@ -140,6 +126,15 @@ version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" +[[package]] +name = "block-buffer" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4" +dependencies = [ + "generic-array", +] + [[package]] name = "block-buffer" version = "0.10.3" @@ -149,6 +144,18 @@ dependencies = [ "generic-array", ] +[[package]] +name = "bstr" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" +dependencies = [ + "lazy_static", + "memchr", + "regex-automata", + "serde", +] + [[package]] name = "bumpalo" version = "3.12.0" @@ -163,7 +170,7 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" [[package]] name = "cairo-felt" -version = "0.2.0" +version = "0.1.3" dependencies = [ "lazy_static", "num-bigint", @@ -175,15 +182,14 @@ dependencies = [ [[package]] name = "cairo-vm" -version = "0.2.0" +version = "0.1.3" dependencies = [ - "anyhow", "assert_matches", "bincode", "cairo-felt", + "clap 3.2.23", "criterion", "generic-array", - "hashbrown 0.13.2", "hex", "iai", "keccak", @@ -199,23 +205,10 @@ dependencies = [ "serde", "serde_bytes", "serde_json", - "sha2", + "sha2 0.10.6", "sha3", "starknet-crypto", "thiserror", - "thiserror-no-std", - "wasm-bindgen-test", -] - -[[package]] -name = "cairo-vm-cli" -version = "0.1.0" -dependencies = [ - "bincode", - "cairo-vm", - "clap 3.2.23", - "nom", - "thiserror", ] [[package]] @@ -295,16 +288,6 @@ dependencies = [ "os_str_bytes", ] -[[package]] -name = "console_error_panic_hook" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" -dependencies = [ - "cfg-if", - "wasm-bindgen", -] - [[package]] name = "cpufeatures" version = "0.2.5" @@ -395,11 +378,12 @@ dependencies = [ [[package]] name = "crypto-bigint" -version = "0.4.9" +version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef" +checksum = "03c6a1d5fa1de37e071642dfa44ec552ca5b299adb128fab16138e24b548fd21" dependencies = [ "generic-array", + "rand_core", "subtle", "zeroize", ] @@ -414,14 +398,25 @@ dependencies = [ "typenum", ] +[[package]] +name = "crypto-mac" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714" +dependencies = [ + "generic-array", + "subtle", +] + [[package]] name = "csv" -version = "1.2.0" +version = "1.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af91f40b7355f82b0a891f50e70399475945bb0b0da4f1700ce60761c9d3e359" +checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1" dependencies = [ + "bstr", "csv-core", - "itoa", + "itoa 0.4.8", "ryu", "serde", ] @@ -461,16 +456,15 @@ version = "0.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f" dependencies = [ - "block-buffer", + "block-buffer 0.10.3", "crypto-common", - "subtle", ] [[package]] name = "either" -version = "1.8.1" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91" +checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797" [[package]] name = "envmnt" @@ -547,21 +541,11 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" -[[package]] -name = "hashbrown" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" -dependencies = [ - "ahash", - "serde", -] - [[package]] name = "heck" -version = "0.4.1" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" +checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9" [[package]] name = "hermit-abi" @@ -589,11 +573,12 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" [[package]] name = "hmac" -version = "0.12.1" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b" dependencies = [ - "digest 0.10.6", + "crypto-mac", + "digest 0.9.0", ] [[package]] @@ -609,7 +594,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399" dependencies = [ "autocfg", - "hashbrown 0.12.3", + "hashbrown", ] [[package]] @@ -630,6 +615,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" + [[package]] name = "itoa" version = "1.0.5" @@ -638,9 +629,9 @@ checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440" [[package]] name = "js-sys" -version = "0.3.61" +version = "0.3.60" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730" +checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47" dependencies = [ "wasm-bindgen", ] @@ -659,9 +650,6 @@ name = "lazy_static" version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" -dependencies = [ - "spin", -] [[package]] name = "libc" @@ -669,12 +657,6 @@ version = "0.2.139" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79" -[[package]] -name = "libm" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb" - [[package]] name = "libmimalloc-sys" version = "0.1.30" @@ -769,7 +751,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" dependencies = [ "autocfg", - "libm", ] [[package]] @@ -794,6 +775,12 @@ version = "11.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" +[[package]] +name = "opaque-debug" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" + [[package]] name = "os_str_bytes" version = "6.4.1" @@ -805,7 +792,6 @@ name = "parse-hyperlinks" version = "0.23.4" dependencies = [ "nom", - "wasm-bindgen-test", ] [[package]] @@ -893,9 +879,9 @@ dependencies = [ [[package]] name = "proptest" -version = "1.1.0" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29f1b898011ce9595050a68e60f90bad083ff2987a695a42357134c8381fba70" +checksum = "1e0d9cc07f18492d879586c92b485def06bc850da3118075cd45d50e9c95b0e5" dependencies = [ "bit-set", "bitflags", @@ -909,7 +895,6 @@ dependencies = [ "regex-syntax", "rusty-fork", "tempfile", - "unarray", ] [[package]] @@ -1012,6 +997,12 @@ dependencies = [ "regex-syntax", ] +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" + [[package]] name = "regex-syntax" version = "0.6.28" @@ -1029,9 +1020,9 @@ dependencies = [ [[package]] name = "rfc6979" -version = "0.3.1" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb" +checksum = "96ef608575f6392792f9ecf7890c00086591d29a83910939d430753f7c050525" dependencies = [ "crypto-bigint", "hmac", @@ -1086,12 +1077,6 @@ dependencies = [ "winapi-util", ] -[[package]] -name = "scoped-tls" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" - [[package]] name = "scopeguard" version = "1.1.0" @@ -1127,9 +1112,9 @@ dependencies = [ [[package]] name = "serde_bytes" -version = "0.11.9" +version = "0.11.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "416bda436f9aab92e02c8e10d49a15ddd339cea90b6e340fe51ed97abb548294" +checksum = "718dc5fff5b36f99093fc49b280cfc96ce6fc824317783bff5a1fed0c7a64819" dependencies = [ "serde", ] @@ -1161,11 +1146,24 @@ version = "1.0.91" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883" dependencies = [ - "itoa", + "itoa 1.0.5", "ryu", "serde", ] +[[package]] +name = "sha2" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" +dependencies = [ + "block-buffer 0.9.0", + "cfg-if", + "cpufeatures", + "digest 0.9.0", + "opaque-debug", +] + [[package]] name = "sha2" version = "0.10.6" @@ -1187,37 +1185,32 @@ dependencies = [ "keccak", ] -[[package]] -name = "spin" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" - [[package]] name = "starknet-crypto" version = "0.2.0" -source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be7d6b2c959fde2a10dbc31d54bdd0307eecb7ef6c05c23a0263e65b57b3e18a" dependencies = [ "crypto-bigint", - "hashbrown 0.13.2", "hex", "hmac", "num-bigint", "num-integer", "num-traits", "rfc6979", - "sha2", + "sha2 0.9.9", "starknet-crypto-codegen", "starknet-curve", "starknet-ff", - "thiserror-no-std", + "thiserror", "zeroize", ] [[package]] name = "starknet-crypto-codegen" version = "0.1.0" -source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6569d70430f0f6edc41f6820d00acf63356e6308046ca01e57eeac22ad258c47" dependencies = [ "starknet-curve", "starknet-ff", @@ -1227,7 +1220,8 @@ dependencies = [ [[package]] name = "starknet-curve" version = "0.1.0" -source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84be6079d3060fdbd8b5335574fef3d3783fa2f7ee6474d08ae0c1e4b0a29ba4" dependencies = [ "starknet-ff", ] @@ -1235,14 +1229,17 @@ dependencies = [ [[package]] name = "starknet-ff" version = "0.2.0" -source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5874510620214ebeac50915b01d67437d8ca10a6682b1de85b93cd01157b58eb" dependencies = [ "ark-ff", + "bigdecimal", "crypto-bigint", "getrandom", "hex", + "num-bigint", "serde", - "thiserror-no-std", + "thiserror", ] [[package]] @@ -1338,26 +1335,6 @@ dependencies = [ "syn", ] -[[package]] -name = "thiserror-impl-no-std" -version = "2.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58e6318948b519ba6dc2b442a6d0b904ebfb8d411a3ad3e07843615a72249758" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "thiserror-no-std" -version = "2.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3ad459d94dd517257cc96add8a43190ee620011bb6e6cdc82dafd97dfafafea" -dependencies = [ - "thiserror-impl-no-std", -] - [[package]] name = "tinytemplate" version = "1.2.1" @@ -1389,12 +1366,6 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81" -[[package]] -name = "unarray" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" - [[package]] name = "unicode-ident" version = "1.0.6" @@ -1419,12 +1390,6 @@ version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" -[[package]] -name = "virtue" -version = "0.0.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b60dcd6a64dd45abf9bd426970c9843726da7fc08f44cd6fcebf68c21220a63" - [[package]] name = "wait-timeout" version = "0.2.0" @@ -1453,9 +1418,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] name = "wasm-bindgen" -version = "0.2.84" +version = "0.2.83" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b" +checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268" dependencies = [ "cfg-if", "wasm-bindgen-macro", @@ -1463,9 +1428,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-backend" -version = "0.2.84" +version = "0.2.83" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9" +checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142" dependencies = [ "bumpalo", "log", @@ -1476,23 +1441,11 @@ dependencies = [ "wasm-bindgen-shared", ] -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - [[package]] name = "wasm-bindgen-macro" -version = "0.2.84" +version = "0.2.83" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5" +checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -1500,9 +1453,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.84" +version = "0.2.83" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6" +checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c" dependencies = [ "proc-macro2", "quote", @@ -1513,33 +1466,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-shared" -version = "0.2.84" +version = "0.2.83" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d" - -[[package]] -name = "wasm-bindgen-test" -version = "0.3.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6db36fc0f9fb209e88fb3642590ae0205bb5a56216dabd963ba15879fe53a30b" -dependencies = [ - "console_error_panic_hook", - "js-sys", - "scoped-tls", - "wasm-bindgen", - "wasm-bindgen-futures", - "wasm-bindgen-test-macro", -] - -[[package]] -name = "wasm-bindgen-test-macro" -version = "0.3.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0734759ae6b3b1717d661fe4f016efcfb9828f5edb4520c18eaee05af3b43be9" -dependencies = [ - "proc-macro2", - "quote", -] +checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f" [[package]] name = "web-sys" diff --git a/Cargo.toml b/Cargo.toml index 7794e20ad5..29b7f9e967 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,88 +1,62 @@ [workspace] -members = [".", "felt", "cairo-vm-cli", "./deps/parse-hyperlinks"] +members = [".", "felt", "./deps/parse-hyperlinks"] [package] name = "cairo-vm" -version = "0.2.0" +version = "0.1.3" edition = "2021" license = "Apache-2.0" description = "Blazing fast Cairo interpreter" +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + [features] -default = ["std", "with_mimalloc"] +default = ["with_mimalloc"] with_mimalloc = ["mimalloc"] -std = [ - "serde_json/std", - "serde_bytes/std", - "bincode/std", - "anyhow/std", - "starknet-crypto/std", - "parse-hyperlinks/std", - "felt/std", -] -alloc = [ - "serde_json/alloc", - "serde_bytes/alloc", - "starknet-crypto/alloc", - "parse-hyperlinks/alloc", - "felt/alloc", -] - - +# This feature will reference every test-oriented feature. # Note that these features are not retro-compatible with the cairo Python VM. -test_utils = [ - "skip_next_instruction_hint", - "hooks", -] # This feature will reference every test-oriented feature +test_utils = ["skip_next_instruction_hint", "hooks"] skip_next_instruction_hint = [] hooks = [] [dependencies] mimalloc = { version = "0.1.29", default-features = false, optional = true } -num-bigint = { version = "0.4", features = ["serde"], default-features = false } -num-traits = { version = "0.2", default-features = false } -num-integer = { version = "0.1.45", default-features = false } -serde = { version = "1.0", features = ["derive"], default-features = false } -serde_bytes = { version = "0.11.9", default-features = false } -serde_json = { version = "1.0", features = [ - "arbitrary_precision", -], default-features = false } -hex = { version = "0.4.3", default-features = false } -bincode = { tag = "v2.0.0-rc.2", git = "https://github.com/bincode-org/bincode.git", default-features = false, features = [ - "serde", -] } -starknet-crypto = { git = "https://github.com/tdelabro/starknet-rs.git", branch = "feature/manual-no-std-bigdecimal", default-features = false } -sha3 = { version = "0.10.1", default-features = false } -rand_core = { version = "0.6.4", default-features = false } -lazy_static = { version = "1.4.0", default-features = false, features = [ - "spin_no_std", -] } -nom = { version = "7", default-features = false } -sha2 = { version = "0.10.2", features = ["compress"], default-features = false } -generic-array = { version = "0.14.6", default-features = false } -keccak = { version = "0.1.2", default-features = false } -hashbrown = { version = "0.13.2", features = ["serde"] } -anyhow = { version = "1.0.69", default-features = false } -thiserror = { version = "1.0.32", default-features = false } -thiserror-no-std = "2.0.2" - +num-bigint = { version = "0.4", features = ["serde"] } +num-traits = "0.2" +num-integer = "0.1.45" +serde = { version = "1.0", features = ["derive"] } +serde_bytes = "0.11.1" +serde_json = { version = "1.0", features = ["arbitrary_precision"] } +hex = "0.4.3" +bincode = "1.2.1" +starknet-crypto = "0.2.0" +clap = { version = "3.2.5", features = ["derive"] } +sha3 = "0.10.1" +rand_core = "0.6.4" +lazy_static = "1.4.0" +nom = "7" +sha2 = { version = "0.10.2", features = ["compress"] } +thiserror = "1.0.32" +generic-array = "0.14.6" +keccak = "0.1.2" # This crate has only one function `take_until_unbalanced` that is # very useful for our parsing purposes: # https://stackoverflow.com/questions/70630556/parse-allowing-nested-parentheses-in-nom # There is a proposal for extending nom::delimited to use this function: # https://github.com/Geal/nom/issues/1253 -parse-hyperlinks = { path = "./deps/parse-hyperlinks", version = "0.23.4", default-features = false } -felt = { package = "cairo-felt", path = "./felt", default-features = false } +parse-hyperlinks = { path = "./deps/parse-hyperlinks", version = "0.23.4" } +felt = { package = "cairo-felt", path = "./felt", version = "0.1.0" } -[target.'cfg(target_arch = "wasm32")'.dev-dependencies] -wasm-bindgen-test = "0.3.34" -assert_matches = "1.5.0" - -[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies] +[dev-dependencies] iai = "0.1" -rusty-hook = "0.11" assert_matches = "1.5.0" -criterion = { version = "0.3", features = ["html_reports"] } + +[dev-dependencies.rusty-hook] +version = "0.11" + +[dev-dependencies.criterion] +version = "0.3" +features = ["html_reports"] [[bench]] path = "bench/iai_benchmark.rs" @@ -94,5 +68,11 @@ path = "bench/criterion_benchmark.rs" name = "criterion_benchmark" harness = false +[[bin]] +name = "cairo-rs-run" +path = "src/main.rs" +bench = false +doc = false + [profile.release] lto = "fat" diff --git a/Makefile b/Makefile index 5173f74552..f87c6cb330 100644 --- a/Makefile +++ b/Makefile @@ -32,7 +32,7 @@ $(TEST_PROOF_DIR)/%.json: $(TEST_PROOF_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_PROOF_DIR):$(PROOF_BENCH_DIR)" $< --output $@ --proof_mode $(TEST_PROOF_DIR)/%.rs.trace $(TEST_PROOF_DIR)/%.rs.memory: $(TEST_PROOF_DIR)/%.json $(RELBIN) - cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory + cargo llvm-cov run --release --no-report -- --layout all --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_PROOF_DIR)/%.trace $(TEST_PROOF_DIR)/%.memory: $(TEST_PROOF_DIR)/%.json cairo-run --layout all --proof_mode --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory @@ -68,7 +68,7 @@ $(TEST_DIR)/%.json: $(TEST_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_DIR):$(BENCH_DIR)" $< --output $@ $(TEST_DIR)/%.rs.trace $(TEST_DIR)/%.rs.memory: $(TEST_DIR)/%.json $(RELBIN) - cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory + cargo llvm-cov run --release --no-report -- --layout all $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_DIR)/%.trace $(TEST_DIR)/%.memory: $(TEST_DIR)/%.json cairo-run --layout all --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory @@ -107,7 +107,7 @@ $(RELBIN): build: $(RELBIN) run: - cargo run -p cairo-vm-cli + cargo run check: cargo check @@ -121,10 +121,6 @@ cairo-rs_trace: $(CAIRO_RS_TRACE) $(CAIRO_RS_MEM) test: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) cargo llvm-cov nextest --no-report --workspace --features test_utils -test-no_std: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) - cargo llvm-cov nextest --no-report --workspace --features test_utils --no-default-features --features alloc -test-wasm: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) - wasm-pack test --node --no-default-features --features alloc clippy: cargo clippy --tests --examples --all-features -- -D warnings @@ -152,22 +148,22 @@ compare_benchmarks: $(COMPILED_BENCHES) cd bench && ./run_benchmarks.sh compare_trace_memory: $(CAIRO_RS_TRACE) $(CAIRO_TRACE) $(CAIRO_RS_MEM) $(CAIRO_MEM) - cd src/tests; ./compare_vm_state.sh trace memory + cd tests; ./compare_vm_state.sh trace memory compare_trace: $(CAIRO_RS_TRACE) $(CAIRO_TRACE) - cd src/tests; ./compare_vm_state.sh trace + cd tests; ./compare_vm_state.sh trace compare_memory: $(CAIRO_RS_MEM) $(CAIRO_MEM) - cd src/tests; ./compare_vm_state.sh memory + cd tests; ./compare_vm_state.sh memory compare_trace_memory_proof: $(COMPILED_PROOF_TESTS) $(CAIRO_RS_TRACE_PROOF) $(CAIRO_TRACE_PROOF) $(CAIRO_RS_MEM_PROOF) $(CAIRO_MEM_PROOF) - cd src/tests; ./compare_vm_state.sh trace memory proof_mode + cd tests; ./compare_vm_state.sh trace memory proof_mode compare_trace_proof: $(CAIRO_RS_TRACE_PROOF) $(CAIRO_TRACE_PROOF) - cd src/tests; ./compare_vm_state.sh trace proof_mode + cd tests; ./compare_vm_state.sh trace proof_mode compare_memory_proof: $(CAIRO_RS_MEM_PROOF) $(CAIRO_MEM_PROOF) - cd src/tests; ./compare_vm_state.sh memory proof_mode + cd tests; ./compare_vm_state.sh memory proof_mode # Run with nightly enable the `doc_cfg` feature wich let us provide clear explaination about which parts of the code are behind a feature flag docs: diff --git a/bench/criterion_benchmark.rs b/bench/criterion_benchmark.rs index 2ca326bbce..4df2f75bc1 100644 --- a/bench/criterion_benchmark.rs +++ b/bench/criterion_benchmark.rs @@ -32,11 +32,10 @@ pub fn criterion_benchmarks(c: &mut Criterion) { ..cairo_vm::cairo_run::CairoRunConfig::default() }; for benchmark_name in build_bench_strings() { - let file_content = std::fs::read(Path::new(&benchmark_name.1)).unwrap(); c.bench_function(&benchmark_name.0, |b| { b.iter(|| { cairo_run::cairo_run( - black_box(&file_content), + black_box(Path::new(&benchmark_name.1)), &cairo_run_config, &mut hint_executor, ) diff --git a/bench/iai_benchmark.rs b/bench/iai_benchmark.rs index 496118035e..9763e99983 100644 --- a/bench/iai_benchmark.rs +++ b/bench/iai_benchmark.rs @@ -4,13 +4,12 @@ use cairo_vm::{ cairo_run::cairo_run, hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, vm::errors::cairo_run_errors::CairoRunError, vm::runners::cairo_runner::CairoRunner, - vm::vm_core::VirtualMachine, }; use iai::{black_box, main}; macro_rules! iai_bench_expand_prog { ($val: ident) => { - fn $val() -> Result<(CairoRunner, VirtualMachine), CairoRunError> { + fn $val() -> Result { let cairo_run_config = cairo_vm::cairo_run::CairoRunConfig { layout: "all", ..cairo_vm::cairo_run::CairoRunConfig::default() @@ -21,12 +20,7 @@ macro_rules! iai_bench_expand_prog { stringify!($val), ".json" )); - let program_content = std::fs::read(path).unwrap(); - cairo_run( - black_box(&program_content), - &cairo_run_config, - &mut hint_executor, - ) + cairo_run(black_box(path), &cairo_run_config, &mut hint_executor) } }; } diff --git a/bench/run_benchmarks.sh b/bench/run_benchmarks.sh index e5506de4c9..624b2e01d0 100755 --- a/bench/run_benchmarks.sh +++ b/bench/run_benchmarks.sh @@ -1,5 +1,5 @@ #!/usr/bin/env sh -tests_path="cairo_programs/benchmarks" +tests_path="../cairo_programs/benchmarks" set -e diff --git a/cairo-vm-cli/Cargo.toml b/cairo-vm-cli/Cargo.toml deleted file mode 100644 index ee0a5fcc1d..0000000000 --- a/cairo-vm-cli/Cargo.toml +++ /dev/null @@ -1,11 +0,0 @@ -[package] -name = "cairo-vm-cli" -version = "0.1.0" -edition = "2021" - -[dependencies] -cairo-vm = { path = ".." } -clap = { version = "3.2.5", features = ["derive"] } -nom = "7" -thiserror = { version = "1.0.32" } -bincode = { tag = "v2.0.0-rc.2", git = "https://github.com/bincode-org/bincode.git" } diff --git a/deps/parse-hyperlinks/Cargo.toml b/deps/parse-hyperlinks/Cargo.toml index 9752d93471..b80392e2c7 100644 --- a/deps/parse-hyperlinks/Cargo.toml +++ b/deps/parse-hyperlinks/Cargo.toml @@ -12,12 +12,4 @@ description = "A Nom parser library for hyperlinks with markup." categories = ["command-line-utilities", "parser-implementations"] [dependencies] -nom = { version = "7.1.1", default-features = false } - -[features] -default = ["std"] -std = ["nom/std"] -alloc = ["nom/alloc"] - -[target.'cfg(target_arch = "wasm32")'.dev-dependencies] -wasm-bindgen-test = "0.3.34" +nom= "7.1.1" diff --git a/deps/parse-hyperlinks/src/lib.rs b/deps/parse-hyperlinks/src/lib.rs index 8da099d0c5..cc1aa7af4c 100644 --- a/deps/parse-hyperlinks/src/lib.rs +++ b/deps/parse-hyperlinks/src/lib.rs @@ -1,5 +1,4 @@ #![allow(dead_code)] -#![cfg_attr(not(feature = "std"), no_std)] use nom::error::Error; use nom::error::ErrorKind; @@ -88,11 +87,7 @@ mod tests { use super::*; use nom::error::ErrorKind; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_take_until_unmatched() { assert_eq!(take_until_unbalanced('(', ')')("abc"), Ok(("", "abc"))); assert_eq!( diff --git a/felt/Cargo.toml b/felt/Cargo.toml index e1a7c221ac..c21a8706fe 100644 --- a/felt/Cargo.toml +++ b/felt/Cargo.toml @@ -1,23 +1,18 @@ [package] name = "cairo-felt" -version = "0.2.0" +version = "0.1.3" edition = "2021" license = "Apache-2.0" description = "Field elements representation for the Cairo VM" -[features] -default = ["std"] -std = [] -alloc = [] +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -num-integer = { version = "0.1.45", default-features = false } -num-bigint = { version = "0.4", features = ["serde"], default-features = false } -num-traits = { version = "0.2.15", default-features = false } -lazy_static = { version = "1.4.0", default-features = false, features = [ - "spin_no_std", -] } -serde = { version = "1.0", features = ["derive"], default-features = false } +num-integer = "0.1.45" +num-bigint = { version = "0.4", features = ["serde"] } +num-traits = "0.2.15" +lazy_static = "1.4.0" +serde = { version = "1.0", features = ["derive"] } [dev-dependencies] proptest = "1.0.0" diff --git a/felt/src/bigint_felt.rs b/felt/src/bigint_felt.rs index e0e24acd64..8c2a9f8e4a 100644 --- a/felt/src/bigint_felt.rs +++ b/felt/src/bigint_felt.rs @@ -1,8 +1,9 @@ -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use alloc::{string::String, vec::Vec}; - -use core::{ - cmp, +use lazy_static::lazy_static; +use num_bigint::{BigInt, BigUint, ToBigInt, U64Digits}; +use num_integer::Integer; +use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; +use serde::{Deserialize, Serialize}; +use std::{ convert::Into, fmt, iter::Sum, @@ -16,11 +17,6 @@ use crate::{FeltOps, ParseFeltError}; pub const FIELD_HIGH: u128 = (1 << 123) + (17 << 64); // this is equal to 10633823966279327296825105735305134080 pub const FIELD_LOW: u128 = 1; -use lazy_static::lazy_static; -use num_bigint::{BigInt, BigUint, ToBigInt, U64Digits}; -use num_integer::Integer; -use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; -use serde::{Deserialize, Serialize}; lazy_static! { static ref CAIRO_PRIME_BIGUINT: BigUint = @@ -152,12 +148,10 @@ impl FeltOps for FeltBigInt { self.val.iter_u64_digits() } - #[cfg(any(feature = "std", feature = "alloc"))] fn to_signed_bytes_le(&self) -> Vec { self.val.to_bytes_le() } - #[cfg(any(feature = "std", feature = "alloc"))] fn to_bytes_be(&self) -> Vec { self.val.to_bytes_be() } @@ -177,7 +171,6 @@ impl FeltOps for FeltBigInt { Self::from(value) } - #[cfg(any(feature = "std", feature = "alloc"))] fn to_str_radix(&self, radix: u32) -> String { self.val.to_str_radix(radix) } @@ -634,7 +627,7 @@ impl Integer for FeltBigInt { } fn lcm(&self, other: &Self) -> Self { - Self::new(cmp::max(&self.val, &other.val)) + Self::new(std::cmp::max(&self.val, &other.val)) } fn mod_floor(&self, other: &Self) -> Self { @@ -836,15 +829,8 @@ mod tests { use super::*; use proptest::prelude::*; - #[cfg(all(not(feature = "std"), feature = "alloc"))] - use alloc::string::ToString; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] // Tests that the result of adding two zeros is zero. - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_zeros() { let a = FeltBigInt::::new(0); let b = FeltBigInt::new(0); @@ -854,7 +840,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of performing add assign with two zeros is zero. fn add_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -913,7 +898,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of multiplying two zeros is zero. fn mul_zeros() { let a = FeltBigInt::::new(0); @@ -924,7 +908,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of multiplying two zeros with assignment is zero. fn mul_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -936,7 +919,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of subtracting two zeros is zero. fn sub_zeros() { let a = FeltBigInt::::new(0); @@ -947,7 +929,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of subtracting two zeros with assignment is zero. fn sub_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -959,7 +940,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_usize_felt() { let a = FeltBigInt::::new(4u32); let b = FeltBigInt::new(2u32); @@ -969,7 +949,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the negative of zero is zero fn negate_zero() { let a = FeltBigInt::::new(0); diff --git a/felt/src/lib.rs b/felt/src/lib.rs index a94818c89b..8c13790d4a 100644 --- a/felt/src/lib.rs +++ b/felt/src/lib.rs @@ -1,9 +1,3 @@ -#![cfg_attr(not(feature = "std"), no_std)] -#[allow(unused_imports)] -#[macro_use] -#[cfg(all(not(feature = "std"), feature = "alloc"))] -pub extern crate alloc; - mod bigint_felt; use bigint_felt::{FeltBigInt, FIELD_HIGH, FIELD_LOW}; @@ -11,8 +5,7 @@ use num_bigint::{BigInt, BigUint, U64Digits}; use num_integer::Integer; use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; use serde::{Deserialize, Serialize}; - -use core::{ +use std::{ convert::Into, fmt, iter::Sum, @@ -22,9 +15,6 @@ use core::{ }, }; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use alloc::{string::String, vec::Vec}; - pub const PRIME_STR: &str = "0x800000000000011000000000000000000000000000000000000000000000001"; // in decimal, this is equal to 3618502788666131213697322783095070105623107215331596699973092056135872020481 pub(crate) trait FeltOps { @@ -38,17 +28,14 @@ pub(crate) trait FeltOps { fn iter_u64_digits(&self) -> U64Digits; - #[cfg(any(feature = "std", feature = "alloc"))] fn to_signed_bytes_le(&self) -> Vec; - #[cfg(any(feature = "std", feature = "alloc"))] fn to_bytes_be(&self) -> Vec; fn parse_bytes(buf: &[u8], radix: u32) -> Option>; fn from_bytes_be(bytes: &[u8]) -> Self; - #[cfg(any(feature = "std", feature = "alloc"))] fn to_str_radix(&self, radix: u32) -> String; #[deprecated] @@ -151,11 +138,9 @@ impl Felt { pub fn iter_u64_digits(&self) -> U64Digits { self.value.iter_u64_digits() } - #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_signed_bytes_le(&self) -> Vec { self.value.to_signed_bytes_le() } - #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_bytes_be(&self) -> Vec { self.value.to_bytes_be() } @@ -169,7 +154,6 @@ impl Felt { value: FeltBigInt::from_bytes_be(bytes), } } - #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_str_radix(&self, radix: u32) -> String { self.value.to_str_radix(radix) } @@ -840,7 +824,6 @@ assert_felt_impl!(Felt); #[cfg(test)] mod test { use super::*; - use core::cmp; use proptest::prelude::*; const FELT_PATTERN: &str = "(0|[1-9][0-9]*)"; @@ -849,7 +832,6 @@ mod test { proptest! { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a new felt doesn't fall outside the range [0, p]. // In this and some of the following tests, The value of {x} can be either [0] or a very large number, in order to try to overflow the value of {p} and thus ensure the modular arithmetic is working correctly. fn new_in_range(ref x in "(0|[1-9][0-9]*)") { @@ -859,7 +841,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a felt created using Felt::from_bytes_be doesn't fall outside the range [0, p]. // In this and some of the following tests, The value of {x} can be either [0] or a very large number, in order to try to overflow the value of {p} and thus ensure the modular arithmetic is working correctly. fn from_bytes_be_in_range(ref x in "(0|[1-9][0-9]*)") { @@ -870,7 +851,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that the negative of a felt doesn't fall outside the range [0, p]. fn neg_in_range(ref x in "(0|[1-9][0-9]*)") { let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -888,7 +868,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a subtraction between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn sub_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -902,7 +881,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a subtraction with assignment between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn sub_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -921,7 +899,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a multiplication between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn mul_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -935,7 +912,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 pairs of {x} and {y} values that are randomly generated each time tests are run, that a multiplication with assignment between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn mul_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -949,7 +925,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 pairs of {x} and {y} values that are randomly generated each time tests are run, that the result of the division of {x} by {y} is the inverse multiplicative of {x} --that is, multiplying the result by {y} returns the original number {x}. The values of {x} and {y} can be either [0] or a very large number. fn div_is_mul_inv(ref x in "(0|[1-9][0-9]*)", ref y in "[1-9][0-9]*") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -965,7 +940,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the left by {shift_amount} of bits (between 0 and 999) returns a result that is inside of the range [0, p]. fn shift_left_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ let value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); @@ -981,7 +955,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the right by {shift_amount} of bits (between 0 and 999) returns a result that is inside of the range [0, p]. fn shift_right_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ let value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); @@ -993,7 +966,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the right by {shift_amount} of bits (between 0 and 999), with assignment, returns a result that is inside of the range [0, p]. // "With assignment" means that the result of the operation is autommatically assigned to the variable value, replacing its previous content. fn shift_right_assign_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ @@ -1006,7 +978,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitAnd operation between them returns a result that is inside of the range [0, p]. fn bitand_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1019,7 +990,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitOr operation between them returns a result that is inside of the range [0, p]. fn bitor_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1031,7 +1001,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitXor operation between them returns a result that is inside of the range [0, p]. fn bitxor_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1043,7 +1012,6 @@ mod test { #[test] #[allow(deprecated)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 values {x} that are randomly generated each time tests are run, that raising {x} to the {y}th power returns a result that is inside of the range [0, p]. fn pow_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "[0-9]{1,2}"){ let base = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1061,7 +1029,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a Sum operation between them returns a result that is inside of the range [0, p]. fn sum_in_range(ref x in "[1-9][0-9]*", ref y in "[0-9][0-9]*"){ let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1074,7 +1041,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property test to check that the remainder of a division between 100 pairs of values {x} and {y},generated at random each time tests are run, falls in the range [0, p]. x and y can either take the value of 0 or a large integer. // In Cairo, the result of x / y is defined to always satisfy the equation (x / y) * y == x, so the remainder is 0 most of the time. fn rem_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { @@ -1093,17 +1059,15 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 Felts {x} generated at random each time tests are run, that converting them into the u64 type returns a result that is inside of the range [0, p]. fn from_u64_and_to_u64_primitive(x in any::()) { let x_felt:Felt = Felt::from_u64(x).unwrap(); let x_u64:u64 = Felt::to_u64(&x_felt).unwrap(); - prop_assert_eq!(x, x_u64); + prop_assert_eq!(x, x_u64); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_i64_and_to_i64_primitive(x in any::()) { let x: i64 = x as i64; let x_felt:Felt = Felt::from_i64(x).unwrap(); @@ -1118,17 +1082,16 @@ mod test { let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); let lcm = x.lcm(&y); - prop_assert!(lcm == cmp::max(x, y)); + prop_assert!(lcm == std::cmp::max(x, y)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property test to check that is_multiple_of(x, y) works. Since we're operating in a prime field, is_multiple_of // will always be true fn is_multiple_of_doesnt_panic(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); - prop_assert!(x.is_multiple_of(&y)); + let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + prop_assert!(x.is_multiple_of(&y)); } #[test] @@ -1330,7 +1293,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of adding two zeroes is zero fn sum_zeros_in_range() { let x = Felt::new(0); @@ -1340,7 +1302,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of multiplying two zeroes is zero fn mul_zeros_in_range() { let x = Felt::new(0); @@ -1350,7 +1311,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of performing a bit and operation between zeroes is zero fn bit_and_zeros_in_range() { let x = Felt::new(0); @@ -1360,7 +1320,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of perfforming a bit or operation between zeroes is zero fn bit_or_zeros_in_range() { let x = Felt::new(0); @@ -1370,7 +1329,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of perfforming a bit xor operation between zeroes is zero fn bit_xor_zeros_in_range() { let x = Felt::new(0); @@ -1380,7 +1338,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the maximum value a Felt can take is equal to (prime - 1) fn upper_bound() { let prime = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); @@ -1390,7 +1347,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the minimum value a Felt can take is equal to zero. fn lower_bound() { let zero = BigUint::zero(); diff --git a/src/cairo_run.rs b/src/cairo_run.rs index 7c6784cdc0..cb50860a0e 100644 --- a/src/cairo_run.rs +++ b/src/cairo_run.rs @@ -2,24 +2,26 @@ use crate::{ hint_processor::hint_processor_definition::HintProcessor, types::program::Program, vm::{ - errors::{cairo_run_errors::CairoRunError, vm_exception::VmException}, + errors::{ + cairo_run_errors::CairoRunError, runner_errors::RunnerError, vm_exception::VmException, + }, runners::cairo_runner::CairoRunner, security::verify_secure_runner, + trace::trace_entry::RelocatedTraceEntry, vm_core::VirtualMachine, }, }; - -use bincode::enc::write::Writer; use felt::Felt; - -#[cfg(feature = "std")] -use thiserror::Error; -#[cfg(not(feature = "std"))] -use thiserror_no_std::Error; +use std::{ + fs::File, + io::{self, BufWriter, Error, ErrorKind, Write}, + path::Path, +}; pub struct CairoRunConfig<'a> { pub entrypoint: &'a str, pub trace_enabled: bool, + pub print_output: bool, pub layout: &'a str, pub proof_mode: bool, pub secure_run: Option, @@ -30,6 +32,7 @@ impl<'a> Default for CairoRunConfig<'a> { CairoRunConfig { entrypoint: "main", trace_enabled: false, + print_output: false, layout: "plain", proof_mode: false, secure_run: None, @@ -38,11 +41,14 @@ impl<'a> Default for CairoRunConfig<'a> { } pub fn cairo_run( - program_content: &[u8], + path: &Path, cairo_run_config: &CairoRunConfig, hint_executor: &mut dyn HintProcessor, -) -> Result<(CairoRunner, VirtualMachine), CairoRunError> { - let program = Program::from_bytes(program_content, Some(cairo_run_config.entrypoint))?; +) -> Result { + let program = match Program::from_file(path, Some(cairo_run_config.entrypoint)) { + Ok(program) => program, + Err(error) => return Err(CairoRunError::Program(error)), + }; let secure_run = cairo_run_config .secure_run @@ -71,81 +77,93 @@ pub fn cairo_run( } cairo_runner.relocate(&mut vm)?; - Ok((cairo_runner, vm)) + if cairo_run_config.print_output { + write_output(&mut cairo_runner, &mut vm)?; + } + + Ok(cairo_runner) } -#[derive(Debug, Error)] -#[error("Failed to encode trace at position {0}, serialize error: {1}")] -pub struct EncodeTraceError(usize, bincode::error::EncodeError); - -/// Writes the trace binary representation. -/// -/// Bincode encodes to little endian by default and each trace entry is composed of -/// 3 usize values that are padded to always reach 64 bit size. -pub fn write_encoded_trace( - relocated_trace: &[crate::vm::trace::trace_entry::RelocatedTraceEntry], - dest: &mut impl Writer, -) -> Result<(), EncodeTraceError> { +pub fn write_output( + cairo_runner: &mut CairoRunner, + vm: &mut VirtualMachine, +) -> Result<(), CairoRunError> { + let mut buffer = BufWriter::new(io::stdout()); + writeln!(&mut buffer, "Program Output: ") + .map_err(|_| CairoRunError::Runner(RunnerError::WriteFail))?; + cairo_runner.write_output(vm, &mut buffer)?; + buffer + .flush() + .map_err(|_| CairoRunError::Runner(RunnerError::WriteFail)) +} + +/// Writes a trace as a binary file. Bincode encodes to little endian by default and each trace +/// entry is composed of 3 usize values that are padded to always reach 64 bit size. +pub fn write_binary_trace( + relocated_trace: &[RelocatedTraceEntry], + trace_file: &Path, +) -> io::Result<()> { + let file = File::create(trace_file)?; + let mut buffer = BufWriter::new(file); + for (i, entry) in relocated_trace.iter().enumerate() { - bincode::serde::encode_into_writer(entry, &mut *dest, bincode::config::legacy()) - .map_err(|e| EncodeTraceError(i, e))?; + bincode::serialize_into(&mut buffer, entry).map_err(|e| { + Error::new( + ErrorKind::Other, + format!("Failed to dump trace at position {i}, serialize error: {e}"), + ) + })?; } - Ok(()) + buffer.flush() } -/// Writes a binary representation of the relocated memory. -/// -/// The memory pairs (address, value) are encoded and concatenated: -/// * address -> 8-byte encoded -/// * value -> 32-byte encoded -pub fn write_encoded_memory( +/* + Writes a binary memory file with the relocated memory as input. + The memory pairs (address, value) are encoded and concatenated in the file + given by the path `memory_file`. + + * address -> 8-byte encoded + * value -> 32-byte encoded +*/ +pub fn write_binary_memory( relocated_memory: &[Option], - dest: &mut impl Writer, -) -> Result<(), EncodeTraceError> { + memory_file: &Path, +) -> io::Result<()> { + let file = File::create(memory_file)?; + let mut buffer = BufWriter::new(file); + // initialize bytes vector that will be dumped to file + let mut memory_bytes: Vec = Vec::new(); for (i, memory_cell) in relocated_memory.iter().enumerate() { match memory_cell { None => continue, Some(unwrapped_memory_cell) => { - encode_relocated_memory(dest, i, unwrapped_memory_cell) - .map_err(|e| EncodeTraceError(i, e))?; + encode_relocated_memory(&mut memory_bytes, i, unwrapped_memory_cell); } } } - Ok(()) + buffer.write_all(&memory_bytes)?; + buffer.flush() } // encodes a given memory cell. -fn encode_relocated_memory( - dest: &mut impl Writer, - addr: usize, - memory_cell: &Felt, -) -> Result<(), bincode::error::EncodeError> { - let config = bincode::config::standard() - .with_little_endian() - .with_fixed_int_encoding() - .skip_fixed_array_length(); - +fn encode_relocated_memory(memory_bytes: &mut Vec, addr: usize, memory_cell: &Felt) { // append memory address to bytes vector using a 8 bytes representation - let addr_bytes: [u8; 8] = (addr as u64).to_le_bytes(); - bincode::encode_into_writer(addr_bytes, &mut *dest, config)?; + let mut addr_bytes = (addr as u64).to_le_bytes().to_vec(); + memory_bytes.append(&mut addr_bytes); // append memory value at address using a 32 bytes representation - let value_bytes = memory_cell.to_signed_bytes_le(); - let mut x = [0; 32]; - x[..value_bytes.len()].copy_from_slice(&value_bytes); - bincode::encode_into_writer(x, &mut *dest, config)?; - - Ok(()) + let mut value_bytes = memory_cell.to_signed_bytes_le(); + value_bytes.resize(32, 0); + memory_bytes.append(&mut value_bytes); } #[cfg(test)] mod tests { use super::*; - use crate::stdlib::prelude::*; use crate::{ hint_processor::{ builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -153,17 +171,15 @@ mod tests { }, utils::test_utils::*, }; - use bincode::enc::write::SliceWriter; - use felt::Felt; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::io::Read; fn run_test_program( - program_content: &[u8], + program_path: &Path, hint_processor: &mut dyn HintProcessor, ) -> Result<(CairoRunner, VirtualMachine), CairoRunError> { - let program = Program::from_bytes(program_content, Some("main")).unwrap(); + let program = + Program::from_file(program_path, Some("main")).map_err(CairoRunError::Program)?; + let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(true); let end = cairo_runner @@ -178,13 +194,9 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_custom_entry_point() { - let program = Program::from_bytes( - include_bytes!("../cairo_programs/not_main.json"), - Some("not_main"), - ) - .unwrap(); + let program_path = Path::new("cairo_programs/not_main.json"); + let program = Program::from_file(program_path, Some("not_main")).unwrap(); let mut vm = vm!(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); @@ -199,65 +211,72 @@ mod tests { assert_eq!(cairo_runner.relocated_memory[2], Some(Felt::new(123))); } + fn compare_files(file_path_1: &Path, file_path_2: &Path) -> io::Result<()> { + let mut file_1 = File::open(file_path_1)?; + let mut file_2 = File::open(file_path_2)?; + + let mut buffer_1 = Vec::new(); + let mut buffer_2 = Vec::new(); + + file_1.read_to_end(&mut buffer_1)?; + file_2.read_to_end(&mut buffer_2)?; + + assert_eq!(&buffer_1.len(), &buffer_2.len()); + + for (buf_byte_1, buf_byte_2) in buffer_1.iter().zip(buffer_2.iter()) { + assert_eq!(buf_byte_1, buf_byte_2); + } + Ok(()) + } + #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_no_data_program() { // a compiled program with no `data` key. // it should fail when the program is loaded. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let no_data_program_path = - include_bytes!("../cairo_programs/manually_compiled/no_data_program.json"); + let no_data_program_path = Path::new("cairo_programs/no_data_program.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(no_data_program_path, &cairo_run_config, &mut hint_processor,).is_err()); + assert!(cairo_run(no_data_program_path, &cairo_run_config, &mut hint_processor).is_err()); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_no_main_program() { // a compiled program with no main scope // it should fail when trying to run initialize_main_entrypoint. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let no_main_program = - include_bytes!("../cairo_programs/manually_compiled/no_main_program.json"); + let no_main_program_path = Path::new("cairo_programs/no_main_program.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(no_main_program, &cairo_run_config, &mut hint_processor,).is_err()); + assert!(cairo_run(no_main_program_path, &cairo_run_config, &mut hint_processor).is_err()); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_invalid_memory() { // the program invalid_memory.json has an invalid memory cell and errors when trying to // decode the instruction. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let invalid_memory = - include_bytes!("../cairo_programs/manually_compiled/invalid_memory.json"); + let invalid_memory = Path::new("cairo_programs/invalid_memory.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(invalid_memory, &cairo_run_config, &mut hint_processor,).is_err()); + assert!(cairo_run(invalid_memory, &cairo_run_config, &mut hint_processor).is_err()); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_output_program() { - let program_content = include_bytes!("../cairo_programs/bitwise_output.json"); + let program_path = Path::new("cairo_programs/bitwise_output.json"); let mut hint_processor = BuiltinHintProcessor::new_empty(); - let (_, mut vm) = run_test_program(program_content, &mut hint_processor) + let (mut cairo_runner, mut vm) = run_test_program(program_path, &mut hint_processor) .expect("Couldn't initialize cairo runner"); - - let mut output_buffer = String::new(); - vm.write_output(&mut output_buffer).unwrap(); - assert_eq!(&output_buffer, "0\n"); + assert!(write_output(&mut cairo_runner, &mut vm).is_ok()); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_binary_trace_file() { - let program_content = include_bytes!("../cairo_programs/struct.json"); - let expected_encoded_trace = - include_bytes!("../cairo_programs/trace_memory/cairo_trace_struct"); + let program_path = Path::new("cairo_programs/struct.json"); + let expected_trace_path = Path::new("cairo_programs/trace_memory/cairo_trace_struct"); + let cairo_rs_trace_path = Path::new("cairo_programs/trace_memory/struct_cairo_rs.trace"); // run test program until the end let mut hint_processor = BuiltinHintProcessor::new_empty(); - let cairo_runner_result = run_test_program(program_content, &mut hint_processor); + let cairo_runner_result = run_test_program(program_path, &mut hint_processor); let (mut cairo_runner, mut vm) = cairo_runner_result.unwrap(); // relocate memory so we can dump it to file @@ -265,49 +284,40 @@ mod tests { assert!(vm.trace.is_some()); assert!(cairo_runner.relocated_trace.is_some()); - let trace_entries = cairo_runner.relocated_trace.unwrap(); - let mut buffer = [0; 24]; - let mut buff_writer = SliceWriter::new(&mut buffer); // write cairo_rs vm trace file - write_encoded_trace(&trace_entries, &mut buff_writer).unwrap(); + assert!( + write_binary_trace(&cairo_runner.relocated_trace.unwrap(), cairo_rs_trace_path).is_ok() + ); // compare that the original cairo vm trace file and cairo_rs vm trace files are equal - assert_eq!(buffer, *expected_encoded_trace); + assert!(compare_files(cairo_rs_trace_path, expected_trace_path).is_ok()); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_binary_memory_file() { - let program_content = include_bytes!("../cairo_programs/struct.json"); - let expected_encoded_memory = - include_bytes!("../cairo_programs/trace_memory/cairo_memory_struct"); + let program_path = Path::new("cairo_programs/struct.json"); + let expected_memory_path = Path::new("cairo_programs/trace_memory/cairo_memory_struct"); + let cairo_rs_memory_path = Path::new("cairo_programs/trace_memory/struct_cairo_rs.memory"); // run test program until the end let mut hint_processor = BuiltinHintProcessor::new_empty(); - let cairo_runner_result = run_test_program(program_content, &mut hint_processor); + let cairo_runner_result = run_test_program(program_path, &mut hint_processor); let (mut cairo_runner, mut vm) = cairo_runner_result.unwrap(); // relocate memory so we can dump it to file assert!(cairo_runner.relocate(&mut vm).is_ok()); - let mut buffer = [0; 120]; - let mut buff_writer = SliceWriter::new(&mut buffer); // write cairo_rs vm memory file - write_encoded_memory(&cairo_runner.relocated_memory, &mut buff_writer).unwrap(); + assert!(write_binary_memory(&cairo_runner.relocated_memory, cairo_rs_memory_path).is_ok()); // compare that the original cairo vm memory file and cairo_rs vm memory files are equal - assert_eq!(*expected_encoded_memory, buffer); + assert!(compare_files(cairo_rs_memory_path, expected_memory_path).is_ok()); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_with_no_trace() { - let program = Program::from_bytes( - include_bytes!("../cairo_programs/struct.json"), - Some("main"), - ) - .unwrap(); - + let program_path = Path::new("cairo_programs/struct.json"); + let program = Program::from_file(program_path, Some("main")).unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/blake2s_hash.rs b/src/hint_processor/builtin_hint_processor/blake2s_hash.rs index 53515fd969..808d50f5c8 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_hash.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_hash.rs @@ -1,4 +1,4 @@ -use crate::stdlib::{ops::Shl, prelude::*}; +use std::ops::Shl; pub const IV: [u32; 8] = [ 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19, @@ -131,11 +131,7 @@ pub fn blake2s_compress( mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_a() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -155,7 +151,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_b() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -175,7 +170,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_c() { //Hashing "Hello World" let h: [u32; 8] = [ @@ -198,7 +192,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_d() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -221,7 +214,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_e() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -244,7 +236,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_f() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -267,7 +258,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_g() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, diff --git a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs index 62a6528e85..7723b41d05 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -15,6 +13,7 @@ use crate::{ }; use felt::Felt; use num_traits::ToPrimitive; +use std::{borrow::Cow, collections::HashMap}; fn get_fixed_size_u32_array( h_range: &Vec>, @@ -222,12 +221,9 @@ mod tests { vm::{errors::memory_errors::MemoryError, vm_memory::memory::Memory}, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_offset_zero() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -249,7 +245,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_empty_segment() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -271,7 +266,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_not_relocatable() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -291,7 +285,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_input_bigger_than_u32() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -320,7 +313,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_input_relocatable() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -341,7 +333,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_valid() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -388,7 +379,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_invalid_segment_taken() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -414,7 +404,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_invalid_no_ids() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -429,7 +418,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_valid_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.low >> (B * i)) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.high >> (B * i)) & MASK for i in range(4)]"; //Create vm @@ -462,7 +450,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_valid_non_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.low >> (B * i)) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.high >> (B * i)) & MASK for i in range(4)]"; //Create vm @@ -495,7 +482,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_bigend_valid_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.high >> (B * (3 - i))) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.low >> (B * (3 - i))) & MASK for i in range(4)])"; //Create vm @@ -528,7 +514,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_bigend_valid_non_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.high >> (B * (3 - i))) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.low >> (B * (3 - i))) & MASK for i in range(4)])"; //Create vm diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index 6f94342a24..db4dd67767 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{any::Any, collections::HashMap, prelude::*, rc::Rc}; - use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -62,6 +60,7 @@ use crate::{ vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; use felt::Felt; +use std::{any::Any, collections::HashMap, rc::Rc}; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; @@ -448,7 +447,6 @@ impl HintProcessor for BuiltinHintProcessor { #[cfg(test)] mod tests { use super::*; - use crate::stdlib::any::Any; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -463,12 +461,9 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::{One, Zero}; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_empty_memory() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -482,7 +477,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_preset_memory() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -498,7 +492,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_ap_is_not_empty() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -523,7 +516,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unknown_hint() { let hint_code = "random_invalid_code"; let mut vm = vm!(); @@ -534,7 +526,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_enter_scope_valid() { let hint_code = "vm_enter_scope({'n': ids.len})"; let mut vm = vm!(); @@ -549,7 +540,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_enter_scope_invalid() { let hint_code = "vm_enter_scope({'n': ids.len})"; let mut vm = vm!(); @@ -570,7 +560,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_valid() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -588,7 +577,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_variable_not_in_scope_error() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -607,7 +595,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_insert_error() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -637,7 +624,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_valid() { let hint_code = "vm_exit_scope()"; let mut vm = vm!(); @@ -651,7 +637,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_invalid() { let hint_code = "vm_exit_scope()"; let mut vm = vm!(); @@ -667,7 +652,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_enter_scope() { let hint_code = "vm_enter_scope()"; //Create vm @@ -685,7 +669,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_valid() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -708,7 +691,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_max_size() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -733,7 +715,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_invalid_input_length() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -755,7 +736,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_invalid_word_size() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -781,7 +761,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_valid() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -802,7 +781,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_nones_in_range() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -825,7 +803,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_expected_integer_at_range() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -857,7 +834,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_hint_add_same_hint_twice() { let mut hint_processor = BuiltinHintProcessor::new_empty(); let hint_func = Rc::new(HintFunc(Box::new(enter_scope))); diff --git a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs index b9cd8c0142..a6a0646f7e 100644 --- a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs +++ b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs @@ -1,8 +1,3 @@ -use crate::stdlib::{ - borrow::{Cow, ToOwned}, - collections::HashMap, - prelude::*, -}; use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -19,6 +14,7 @@ use crate::{ }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; +use std::{borrow::Cow, collections::HashMap}; // Constants in package "starkware.cairo.common.cairo_keccak.keccak". const BYTES_IN_WORD: &str = "starkware.cairo.common.cairo_keccak.keccak.BYTES_IN_WORD"; @@ -256,7 +252,6 @@ pub fn u64_array_to_mayberelocatable_vec(array: &[u64]) -> Vec #[cfg(test)] mod tests { use super::*; - use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -274,12 +269,9 @@ mod tests { }, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn keccak_write_args_valid_test() { let hint_code = "segments.write_arg(ids.inputs, [ids.low % 2 ** 64, ids.low // 2 ** 64])\nsegments.write_arg(ids.inputs + 2, [ids.high % 2 ** 64, ids.high // 2 ** 64])"; let mut vm = vm_with_range_check!(); @@ -297,7 +289,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn keccak_write_args_write_error() { let hint_code = "segments.write_arg(ids.inputs, [ids.low % 2 ** 64, ids.low // 2 ** 64])\nsegments.write_arg(ids.inputs + 2, [ids.high % 2 ** 64, ids.high // 2 ** 64])"; let mut vm = vm_with_range_check!(); @@ -311,7 +302,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compare_bytes_in_word_nondet_valid() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; @@ -338,7 +328,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compare_keccak_full_rate_in_bytes_nondet_valid() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; @@ -367,7 +356,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn block_permutation_valid_test() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; diff --git a/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs b/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs index 3767fce2ff..ab222d1ecf 100644 --- a/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs @@ -1,9 +1,8 @@ -use crate::stdlib::{any::Any, cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; - use crate::{ types::{exec_scope::ExecutionScopes, relocatable::MaybeRelocatable}, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; +use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; use crate::{ any_box, @@ -258,7 +257,6 @@ mod tests { use crate::hint_processor::builtin_hint_processor::dict_manager::Dictionary; use crate::hint_processor::builtin_hint_processor::hint_code; use crate::hint_processor::hint_processor_definition::HintProcessor; - use crate::stdlib::collections::HashMap; use crate::types::exec_scope::ExecutionScopes; use crate::vm::vm_memory::memory::Memory; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; @@ -270,12 +268,9 @@ mod tests { vm::{errors::memory_errors::MemoryError, vm_core::VirtualMachine}, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::collections::HashMap; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_with_initial_dict_empty() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -307,7 +302,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_with_no_initial_dict() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -319,7 +313,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_ap_is_taken() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -344,7 +337,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_valid() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -372,7 +364,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_invalid_key() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -390,7 +381,6 @@ mod tests { ); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_no_tracker() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -411,7 +401,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_default_dict_new_valid() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_default_dict(segments, ids.default_value)"; let mut vm = vm!(); @@ -443,7 +432,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_default_dict_new_no_default_value() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_default_dict(segments, ids.default_value)"; let mut vm = vm!(); @@ -457,7 +445,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_default_valid_empty_dict() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -485,7 +472,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_default_valid_overwrite_value() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -513,7 +499,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_simple_valid_overwrite_value() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -542,7 +527,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_simple_valid_cant_write_new_key() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -567,7 +551,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_valid() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -592,7 +575,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_valid_no_change() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -617,7 +599,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_invalid_wrong_prev_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -647,7 +628,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_invalid_wrong_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -671,7 +651,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -696,7 +675,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid_no_change() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -721,7 +699,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_invalid_wrong_prev_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -751,7 +728,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_invalid_wrong_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -781,7 +757,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid_no_key_prev_value_equals_default() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -806,7 +781,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_valid_empty_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -835,7 +809,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_valid_non_empty_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -867,7 +840,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_invalid_no_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -888,7 +860,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_no_tracker() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -909,7 +880,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_valid() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -929,7 +899,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_mismatched_dict_ptr() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -952,7 +921,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_valid_relocatable_new_value() { let mut vm = vm!(); //Initialize fp diff --git a/src/hint_processor/builtin_hint_processor/dict_manager.rs b/src/hint_processor/builtin_hint_processor/dict_manager.rs index 28102ac887..5d1b1ff5a9 100644 --- a/src/hint_processor/builtin_hint_processor/dict_manager.rs +++ b/src/hint_processor/builtin_hint_processor/dict_manager.rs @@ -1,4 +1,4 @@ -use crate::stdlib::collections::HashMap; +use std::collections::HashMap; use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, @@ -202,18 +202,13 @@ mod tests { use crate::{relocatable, utils::test_utils::*, vm::vm_core::VirtualMachine}; use assert_matches::assert_matches; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_manager() { let dict_manager = DictManager::new(); assert_eq!(dict_manager.trackers, HashMap::new()); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_tracker_empty() { let dict_tracker = DictTracker::new_empty(relocatable!(1, 0)); assert_eq!( @@ -224,7 +219,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_tracker_default() { let dict_tracker = DictTracker::new_default_dict(relocatable!(1, 0), &MaybeRelocatable::from(5), None); @@ -239,7 +233,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_empty() { let mut vm = vm!(); let mut dict_manager = DictManager::new(); @@ -254,7 +247,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_default() { let mut dict_manager = DictManager::new(); let mut vm = vm!(); @@ -273,7 +265,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_with_initial_dict() { let mut dict_manager = DictManager::new(); let mut vm = vm!(); @@ -293,7 +284,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_default_dict_with_initial_dict() { let mut dict_manager = DictManager::new(); let mut initial_dict = HashMap::::new(); @@ -318,7 +308,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_empty_same_segment() { let mut dict_manager = DictManager::new(); dict_manager @@ -332,7 +321,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_default_dict_empty_same_segment() { let mut dict_manager = DictManager::new(); dict_manager.trackers.insert( @@ -347,7 +335,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dictionary_get_insert_simple() { let mut dictionary = Dictionary::SimpleDictionary(HashMap::new()); dictionary.insert(&MaybeRelocatable::from(1), &MaybeRelocatable::from(2)); @@ -359,7 +346,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dictionary_get_insert_default() { let mut dictionary = Dictionary::DefaultDictionary { dict: HashMap::new(), diff --git a/src/hint_processor/builtin_hint_processor/find_element_hint.rs b/src/hint_processor/builtin_hint_processor/find_element_hint.rs index cd0b013b3a..1e559fa252 100644 --- a/src/hint_processor/builtin_hint_processor/find_element_hint.rs +++ b/src/hint_processor/builtin_hint_processor/find_element_hint.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -15,6 +13,7 @@ use crate::{ }; use felt::Felt; use num_traits::{Signed, ToPrimitive}; +use std::collections::HashMap; pub fn find_element( vm: &mut VirtualMachine, @@ -133,7 +132,6 @@ pub fn search_sorted_lower( #[cfg(test)] mod tests { use super::*; - use crate::stdlib::string::ToString; use crate::{ any_box, hint_processor::{ @@ -149,9 +147,7 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::{One, Zero}; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; fn init_vm_ids_data( values_to_override: HashMap, @@ -221,15 +217,16 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_found_by_search() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); - assert_matches!(run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), Ok(())); + assert_matches!( + run_hint!(vm, ids_data, hint_code::FIND_ELEMENT.to_string()), + Ok(()) + ); check_memory![vm.segments.memory, ((1, 3), 1)]; } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_found_by_oracle() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_index", Felt::one())]; @@ -241,7 +238,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_not_found_search() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "key".to_string(), @@ -254,7 +250,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_not_found_oracle() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_index", Felt::new(2))]; @@ -265,7 +260,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_failed_ids_get_from_mem() { let mut vm = vm!(); vm.run_context.fp = 5; @@ -278,7 +272,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_not_int_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -292,7 +285,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_zero_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -305,7 +297,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_negative_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -318,7 +309,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_not_int_n_elms() { let relocatable = MaybeRelocatable::from((1, 2)); let (mut vm, ids_data) = @@ -331,7 +321,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_negative_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -344,14 +333,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_empty_scope() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!(run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), Ok(())); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_n_elms_gt_max_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_max_size", Felt::one())]; @@ -362,7 +349,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_key_not_int() { let relocatable = MaybeRelocatable::from((1, 4)); let (mut vm, ids_data) = @@ -374,7 +360,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!( @@ -386,7 +371,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_no_matches() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "key".to_string(), @@ -400,7 +384,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_not_int_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -414,7 +397,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_zero_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -427,7 +409,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_negative_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -440,7 +421,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_not_int_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -454,7 +434,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_negative_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -467,7 +446,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_empty_scope() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!( @@ -477,7 +455,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_n_elms_gt_max_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_max_size", Felt::one())]; diff --git a/src/hint_processor/builtin_hint_processor/hint_utils.rs b/src/hint_processor/builtin_hint_processor/hint_utils.rs index 796ebe2911..eb31045b2a 100644 --- a/src/hint_processor/builtin_hint_processor/hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/hint_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; - use felt::Felt; use crate::hint_processor::hint_processor_definition::HintReference; @@ -14,6 +12,8 @@ use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; use crate::vm::errors::hint_errors::HintError; use crate::vm::vm_core::VirtualMachine; +use std::borrow::Cow; +use std::collections::HashMap; //Inserts value into the address of the given ids variable pub fn insert_value_from_var_name( @@ -122,7 +122,6 @@ pub fn get_reference_from_var_name<'a>( #[cfg(test)] mod tests { use super::*; - use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ hint_processor::hint_processor_definition::HintReference, @@ -135,11 +134,7 @@ mod tests { }; use assert_matches::assert_matches; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_immediate_value() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -154,7 +149,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -168,7 +162,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_var_name_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); @@ -182,7 +175,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -196,7 +188,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -211,7 +202,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -225,7 +215,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_from_var_name_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); @@ -239,7 +228,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 1)]; @@ -253,7 +241,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index af2c259fdf..38a5bb348c 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{cmp, collections::HashMap, ops::Shl, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -14,6 +12,7 @@ use crate::{ use felt::Felt; use num_traits::{One, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; +use std::{cmp, collections::HashMap, ops::Shl}; /* Implements hint: %{ diff --git a/src/hint_processor/builtin_hint_processor/math_utils.rs b/src/hint_processor/builtin_hint_processor/math_utils.rs index 8a12232418..f99246b10e 100644 --- a/src/hint_processor/builtin_hint_processor/math_utils.rs +++ b/src/hint_processor/builtin_hint_processor/math_utils.rs @@ -1,11 +1,4 @@ -use crate::stdlib::{ - collections::HashMap, - ops::{Shl, Shr}, - prelude::*, -}; - use crate::utils::CAIRO_PRIME; - use crate::{ any_box, hint_processor::{ @@ -28,6 +21,11 @@ use num_bigint::BigUint; use num_integer::Integer; use num_traits::One; use num_traits::{Signed, Zero}; +use std::{ + any::Any, + collections::HashMap, + ops::{Shl, Shr}, +}; use super::hint_utils::get_maybe_relocatable_from_var_name; @@ -538,7 +536,6 @@ fn div_prime_by_bound(bound: Felt) -> Result { #[cfg(test)] mod tests { use super::*; - use crate::stdlib::ops::Shl; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -559,12 +556,9 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::Zero; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::{any::Any, ops::Shl}; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_false() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -582,7 +576,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_true() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -600,7 +593,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] //This test contemplates the case when the number itself is negative, but it is within the range (-prime, -range_check_bound) //Making the comparison return 1 (true) fn run_is_nn_hint_true_border_case() { @@ -625,7 +617,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_no_range_check_builtin() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm!(); @@ -645,7 +636,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_incorrect_ids() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -661,7 +651,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_cant_get_ids_from_memory() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -680,7 +669,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_ids_are_relocatable_values() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -699,7 +687,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_le_felt_valid() { let hint_code = ASSERT_LE_FELT; let mut constants = HashMap::new(); @@ -729,7 +716,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_le_felt_hint_true() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm_with_range_check!(); @@ -746,7 +732,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_le_felt_hint_inconsistent_memory() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm_with_range_check!(); @@ -771,7 +756,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_le_felt_hint_incorrect_ids() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm!(); @@ -786,7 +770,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_valid() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -802,7 +785,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_invalid() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -820,7 +802,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -837,7 +818,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_a_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -855,7 +835,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm!(); @@ -874,7 +853,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_reference_is_not_in_memory() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -891,7 +869,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_invalid() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -919,7 +896,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_a_is_not_integer() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -947,7 +923,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_b_is_not_integer() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -975,7 +950,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_out_of_range_false() { let hint_code = "memory[ap] = 0 if 0 <= ((-ids.a - 1) % PRIME) < range_check_builtin.bound else 1"; @@ -993,7 +967,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_out_of_range_true() { let hint_code = "memory[ap] = 0 if 0 <= ((-ids.a - 1) % PRIME) < range_check_builtin.bound else 1"; @@ -1010,7 +983,6 @@ mod tests { check_memory![vm.segments.memory, ((1, 0), 0)]; } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_false() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1031,7 +1003,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1045,7 +1016,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_bignum_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1069,7 +1039,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_false() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1090,7 +1059,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1104,7 +1072,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_non_equal_relocatable_diff_index() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1124,7 +1091,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_and_integer() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1146,7 +1112,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_true() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1162,7 +1127,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_false() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1183,7 +1147,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_incorrect_id() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1201,7 +1164,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_expected_integer_error() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1220,7 +1182,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_assertion_invalid() { let hint_code = "assert ids.value == 0, 'split_int(): value is out of range.'"; let mut vm = vm!(); @@ -1237,7 +1198,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_assertion_valid() { let hint_code = "assert ids.value == 0, 'split_int(): value is out of range.'"; let mut vm = vm!(); @@ -1251,7 +1211,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_valid() { let hint_code = "memory[ids.output] = res = (int(ids.value) % PRIME) % ids.base\nassert res < ids.bound, f'split_int(): Limb {res} is out of range.'"; let mut vm = vm!(); @@ -1267,7 +1226,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_invalid() { let hint_code = "memory[ids.output] = res = (int(ids.value) % PRIME) % ids.base\nassert res < ids.bound, f'split_int(): Limb {res} is out of range.'"; let mut vm = vm!(); @@ -1290,7 +1248,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_true() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1309,7 +1266,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_false() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1327,7 +1283,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_outside_valid_range() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1354,7 +1309,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_is_positive_not_empty() { let hint_code ="from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; let mut vm = vm_with_range_check!(); @@ -1380,7 +1334,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_valid() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1397,7 +1350,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_invalid_negative_number() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1417,7 +1369,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_invalid_mismatched_root() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1443,7 +1394,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_success() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1459,7 +1409,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_out_of_range() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1480,7 +1429,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm!(); @@ -1499,7 +1447,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_inconsitent_memory() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1525,7 +1472,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1543,7 +1489,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_success() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1559,7 +1504,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_negative_quotient() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1575,7 +1519,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_out_of_range() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1596,7 +1539,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm!(); @@ -1615,7 +1557,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_inconsitent_memory() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1641,7 +1582,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1659,7 +1599,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_250_bit_valid() { let hint_code = "from starkware.cairo.common.math_utils import as_int\n\n# Correctness check.\nvalue = as_int(ids.value, PRIME) % PRIME\nassert value < ids.UPPER_BOUND, f'{value} is outside of the range [0, 2**250).'\n\n# Calculation for the assertion.\nids.high, ids.low = divmod(ids.value, ids.SHIFT)"; let mut vm = vm!(); @@ -1677,7 +1616,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_250_bit_invalid() { let hint_code = "from starkware.cairo.common.math_utils import as_int\n\n# Correctness check.\nvalue = as_int(ids.value, PRIME) % PRIME\nassert value < ids.UPPER_BOUND, f'{value} is outside of the range [0, 2**250).'\n\n# Calculation for the assertion.\nids.high, ids.low = divmod(ids.value, ids.SHIFT)"; let mut vm = vm!(); @@ -1702,7 +1640,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_ok() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1731,7 +1668,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1753,7 +1689,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_fails_first_insert() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1788,7 +1723,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_fails_second_insert() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1823,7 +1757,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_value_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1846,7 +1779,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_ok() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1862,7 +1794,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_assert_fails() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1879,7 +1810,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1897,7 +1827,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_a_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1915,7 +1844,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_b_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1933,7 +1861,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_ok_failed_to_get_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; diff --git a/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs b/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs index 4ac912179b..a7e8d36ad6 100644 --- a/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -13,6 +11,7 @@ use crate::{ }; use felt::Felt; use num_traits::{One, Zero}; +use std::{any::Any, collections::HashMap}; //Implements hint: memory[ap] = segments.add() pub fn add_segment(vm: &mut VirtualMachine) -> Result<(), HintError> { @@ -83,11 +82,7 @@ mod tests { }; use assert_matches::assert_matches; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_valid() { let mut vm = vm!(); // initialize memory segments @@ -113,7 +108,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_invalid_expected_integer() { let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/memset_utils.rs b/src/hint_processor/builtin_hint_processor/memset_utils.rs index f915c544f2..8d13dd38da 100644 --- a/src/hint_processor/builtin_hint_processor/memset_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memset_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -13,6 +11,7 @@ use crate::{ }; use felt::Felt; use num_traits::Signed; +use std::{any::Any, collections::HashMap}; // Implements hint: // %{ vm_enter_scope({'n': ids.n}) %} @@ -57,7 +56,6 @@ pub fn memset_continue_loop( #[cfg(test)] mod tests { use super::*; - use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -74,11 +72,7 @@ mod tests { use assert_matches::assert_matches; use num_traits::{One, Zero}; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_enter_scope_valid() { let hint_code = "vm_enter_scope({'n': ids.n})"; let mut vm = vm!(); @@ -91,7 +85,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_enter_scope_invalid() { let hint_code = "vm_enter_scope({'n': ids.n})"; let mut vm = vm!(); @@ -109,7 +102,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_valid_continue_loop_equal_1() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -127,7 +119,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_valid_continue_loop_equal_5() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -146,7 +137,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_variable_not_in_scope_error() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -168,7 +158,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_insert_error() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/pow_utils.rs b/src/hint_processor/builtin_hint_processor/pow_utils.rs index 7986ac277b..6de8b9e877 100644 --- a/src/hint_processor/builtin_hint_processor/pow_utils.rs +++ b/src/hint_processor/builtin_hint_processor/pow_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -12,6 +10,7 @@ use crate::{ }; use felt::Felt; use num_integer::Integer; +use std::collections::HashMap; /* Implements hint: @@ -54,12 +53,9 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::One; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_ok() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -73,7 +69,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_incorrect_ids() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -90,7 +85,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_incorrect_references() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -107,7 +101,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_prev_locs_exp_is_not_integer() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -126,7 +119,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_invalid_memory_insert() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs b/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs index 4c8d59772e..68670332bd 100644 --- a/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs @@ -1,4 +1,3 @@ -use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -15,6 +14,7 @@ use crate::{ vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; use felt::Felt; +use std::{borrow::Cow, collections::HashMap}; #[derive(Debug, PartialEq)] pub(crate) struct BigInt3<'a> { @@ -109,8 +109,6 @@ mod tests { BuiltinHintProcessor, HintProcessorData, }; use crate::hint_processor::hint_processor_definition::HintProcessor; - use crate::stdlib::ops::Shl; - use crate::stdlib::string::ToString; use crate::types::exec_scope::ExecutionScopes; use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; @@ -122,12 +120,10 @@ mod tests { use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use assert_matches::assert_matches; use num_traits::One; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; + use std::ops::Shl; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); @@ -164,7 +160,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_value_not_in_scope() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); @@ -180,7 +175,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_split_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs b/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs index 5e2cabf9e5..cad7bd38a1 100644 --- a/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs @@ -1,8 +1,3 @@ -use crate::stdlib::{ - collections::HashMap, - ops::{BitAnd, Shl}, - prelude::*, -}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -22,6 +17,10 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::{One, Zero}; +use std::{ + collections::HashMap, + ops::{BitAnd, Shl}, +}; use super::bigint_utils::BigInt3; @@ -331,7 +330,6 @@ pub fn ec_mul_inner( #[cfg(test)] mod tests { use super::*; - use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -352,12 +350,9 @@ mod tests { }, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_negate_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\ny = pack(ids.point.y, PRIME) % SECP_P\n# The modulo operation in python always returns a nonnegative number.\nvalue = (-y) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -401,7 +396,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_compute_doubling_slope_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\nfrom starkware.python.math_utils import ec_double_slope\n\n# Compute the slope.\nx = pack(ids.point.x, PRIME)\ny = pack(ids.point.y, PRIME)\nvalue = slope = ec_double_slope(point=(x, y), alpha=0, p=SECP_P)"; let mut vm = vm_with_range_check!(); @@ -463,7 +457,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_compute_slope_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\nfrom starkware.python.math_utils import line_slope\n\n# Compute the slope.\nx0 = pack(ids.point0.x, PRIME)\ny0 = pack(ids.point0.y, PRIME)\nx1 = pack(ids.point1.x, PRIME)\ny1 = pack(ids.point1.y, PRIME)\nvalue = slope = line_slope(point1=(x0, y0), point2=(x1, y1), p=SECP_P)"; let mut vm = vm_with_range_check!(); @@ -535,7 +528,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_double_assign_new_x_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nslope = pack(ids.slope, PRIME)\nx = pack(ids.point.x, PRIME)\ny = pack(ids.point.y, PRIME)\n\nvalue = new_x = (pow(slope, 2, SECP_P) - 2 * x) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -619,7 +611,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_double_assign_new_y_ok() { let hint_code = "value = new_y = (slope * (x - new_x) - y) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -689,7 +680,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_fast_ec_add_assign_new_x_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nslope = pack(ids.slope, PRIME)\nx0 = pack(ids.point0.x, PRIME)\nx1 = pack(ids.point1.x, PRIME)\ny0 = pack(ids.point0.y, PRIME)\n\nvalue = new_x = (pow(slope, 2, SECP_P) - x0 - x1) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -767,7 +757,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_fast_ec_add_assign_new_y_ok() { let hint_code = "value = new_y = (slope * (x0 - new_x) - y0) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -839,7 +828,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_mul_inner_ok() { let hint_code = "memory[ap] = (ids.scalar % PRIME) % 2"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs index fea37db3ea..3fb1a80068 100644 --- a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, ops::Shl, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -17,6 +15,7 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::{One, Zero}; +use std::{collections::HashMap, ops::Shl}; use super::{bigint_utils::BigInt3, secp_utils::pack}; @@ -162,7 +161,6 @@ pub fn is_zero_assign_scope_variables( #[cfg(test)] mod tests { use super::*; - use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -183,12 +181,9 @@ mod tests { }, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -226,7 +221,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -264,7 +258,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_invalid_memory_insert() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -310,7 +303,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_reduce_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nvalue = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -363,7 +355,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_reduce_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nvalue = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -402,7 +393,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_pack_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nx = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -458,7 +448,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_pack_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nx = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -498,7 +487,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_ok_true() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -525,7 +513,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_ok_false() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -552,7 +539,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_scope_error() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -573,7 +559,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_invalid_memory_insert() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -603,7 +588,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_assign_scope_variables_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P\nfrom starkware.python.math_utils import div_mod\n\nvalue = x_inv = div_mod(1, x, SECP_P)"; let mut vm = vm_with_range_check!(); @@ -658,7 +642,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_assign_scope_variables_scope_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P\nfrom starkware.python.math_utils import div_mod\n\nvalue = x_inv = div_mod(1, x, SECP_P)"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs b/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs index 60b0232daf..7952efd40b 100644 --- a/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs @@ -1,9 +1,9 @@ -use crate::stdlib::{collections::HashMap, ops::Shl, prelude::*}; - use crate::vm::errors::hint_errors::HintError; use felt::Felt; use num_traits::Zero; +use std::collections::HashMap; +use std::ops::Shl; use super::bigint_utils::BigInt3; @@ -64,19 +64,16 @@ pub(crate) fn pack(num: BigInt3) -> num_bigint::BigInt { #[cfg(test)] mod tests { + use std::borrow::Cow; + use super::*; - use crate::stdlib::{borrow::Cow, string::ToString}; use crate::utils::test_utils::*; use assert_matches::assert_matches; use felt::felt_str; use num_bigint::BigUint; use num_traits::One; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn secp_split() { let mut constants = HashMap::new(); constants.insert(BASE_86.to_string(), Felt::one() << 86_usize); @@ -147,7 +144,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn secp_pack() { let pack_1 = pack(BigInt3 { d0: Cow::Borrowed(&Felt::new(10_i32)), diff --git a/src/hint_processor/builtin_hint_processor/secp/signature.rs b/src/hint_processor/builtin_hint_processor/secp/signature.rs index 8364e94c6a..25d3375c70 100644 --- a/src/hint_processor/builtin_hint_processor/secp/signature.rs +++ b/src/hint_processor/builtin_hint_processor/secp/signature.rs @@ -1,9 +1,3 @@ -use crate::stdlib::{ - collections::HashMap, - ops::{Shl, Shr}, - prelude::*, -}; - use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -22,6 +16,10 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::One; +use std::{ + collections::HashMap, + ops::{Shl, Shr}, +}; use super::bigint_utils::BigInt3; @@ -150,8 +148,6 @@ pub fn get_point_from_x( #[cfg(test)] mod tests { use super::*; - use crate::stdlib::ops::Shl; - use crate::stdlib::string::ToString; use crate::types::errors::math_errors::MathError; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ @@ -169,12 +165,9 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::Zero; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::{any::Any, ops::Shl}; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn safe_div_ok() { let hint_code = hint_code::DIV_MOD_N_PACKED_DIVMOD; let mut vm = vm!(); @@ -207,7 +200,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn safe_div_fail() { let mut exec_scopes = scope![ ("a", BigInt::zero()), @@ -237,7 +229,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_point_from_x_ok() { let hint_code = hint_code::GET_POINT_FROM_X; let mut vm = vm!(); @@ -277,7 +268,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_point_from_x_negative_y() { let hint_code = hint_code::GET_POINT_FROM_X; let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/segments.rs b/src/hint_processor/builtin_hint_processor/segments.rs index 6ca1e525ff..45a779ca26 100644 --- a/src/hint_processor/builtin_hint_processor/segments.rs +++ b/src/hint_processor/builtin_hint_processor/segments.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, prelude::*}; - use crate::hint_processor::builtin_hint_processor::hint_utils::get_ptr_from_var_name; use crate::hint_processor::{ builtin_hint_processor::hint_utils::insert_value_from_var_name, @@ -8,6 +6,7 @@ use crate::hint_processor::{ use crate::serde::deserialize_program::ApTracking; use crate::vm::errors::hint_errors::HintError; use crate::vm::vm_core::VirtualMachine; +use std::collections::HashMap; /* Implements hint: @@ -64,12 +63,9 @@ mod tests { }, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_relocate_segment() { let hint_code = hint_code::RELOCATE_SEGMENT; //Initialize vm @@ -92,7 +88,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_temporary_array() { let hint_code = hint_code::TEMPORARY_ARRAY; //Initialize vm diff --git a/src/hint_processor/builtin_hint_processor/set.rs b/src/hint_processor/builtin_hint_processor/set.rs index 79ae9984ad..330f1435d3 100644 --- a/src/hint_processor/builtin_hint_processor/set.rs +++ b/src/hint_processor/builtin_hint_processor/set.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -13,6 +11,7 @@ use crate::{ }; use felt::Felt; use num_traits::{One, ToPrimitive, Zero}; +use std::collections::HashMap; pub fn set_add( vm: &mut VirtualMachine, @@ -87,9 +86,7 @@ mod tests { }, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; const HINT_CODE: &str = "assert ids.elm_size > 0\nassert ids.set_ptr <= ids.set_end_ptr\nelm_list = memory.get_range(ids.elm_ptr, ids.elm_size)\nfor i in range(0, ids.set_end_ptr - ids.set_ptr, ids.elm_size):\n if memory.get_range(ids.set_ptr + i, ids.elm_size) == elm_list:\n ids.index = i // ids.elm_size\n ids.is_elm_in_set = 1\n break\nelse:\n ids.is_elm_in_set = 0"; @@ -133,7 +130,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_add_new_elem() { let (mut vm, ids_data) = init_vm_ids_data(None, None, None, None); assert_matches!(run_hint!(vm, ids_data, HINT_CODE), Ok(())); @@ -148,7 +144,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_add_already_exists() { let (mut vm, ids_data) = init_vm_ids_data(None, None, Some(1), Some(3)); assert_matches!(run_hint!(vm, ids_data, HINT_CODE), Ok(())); @@ -156,7 +151,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn elm_size_negative() { let (mut vm, ids_data) = init_vm_ids_data(None, Some(-2), None, None); assert_matches!( @@ -166,7 +160,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn elm_size_zero() { let (mut vm, ids_data) = init_vm_ids_data(None, Some(0), None, None); assert_matches!( @@ -177,7 +170,6 @@ mod tests { ); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_ptr_gt_set_end_ptr() { let (mut vm, ids_data) = init_vm_ids_data(Some((2, 3)), None, None, None); assert_matches!( diff --git a/src/hint_processor/builtin_hint_processor/sha256_utils.rs b/src/hint_processor/builtin_hint_processor/sha256_utils.rs index 096ba782d2..ee7f92a31f 100644 --- a/src/hint_processor/builtin_hint_processor/sha256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/sha256_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -16,6 +14,7 @@ use felt::Felt; use generic_array::GenericArray; use num_traits::{One, Zero}; use sha2::compress256; +use std::collections::HashMap; use crate::hint_processor::hint_processor_definition::HintReference; @@ -130,11 +129,7 @@ mod tests { }; use assert_matches::assert_matches; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_input_one() { let mut vm = vm_with_range_check!(); vm.segments = segments![((1, 1), 7)]; @@ -146,7 +141,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_input_zero() { let mut vm = vm_with_range_check!(); vm.segments = segments![((1, 1), 3)]; @@ -158,7 +152,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_ok() { let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/signature.rs b/src/hint_processor/builtin_hint_processor/signature.rs index 9aa273bba7..b02011b406 100644 --- a/src/hint_processor/builtin_hint_processor/signature.rs +++ b/src/hint_processor/builtin_hint_processor/signature.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, prelude::*}; - use num_integer::Integer; use crate::{ @@ -14,6 +12,7 @@ use crate::{ vm_core::VirtualMachine, }, }; +use std::collections::HashMap; pub fn verify_ecdsa_signature( vm: &mut VirtualMachine, @@ -67,12 +66,9 @@ mod tests { }, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_ecdsa_signature_valid() { let mut vm = vm!(); vm.builtin_runners = vec![( diff --git a/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs b/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs index c4bb1a0ebf..d12193e669 100644 --- a/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs +++ b/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -21,6 +19,7 @@ use crate::{ use felt::Felt; use num_integer::Integer; use num_traits::{One, ToPrimitive, Zero}; +use std::collections::HashMap; fn get_access_indices( exec_scopes: &mut ExecutionScopes, @@ -317,9 +316,7 @@ mod tests { }; use assert_matches::assert_matches; use felt::felt_str; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; //Hint code as consts const SQUASH_DICT_INNER_FIRST_ITERATION : &str = "current_access_indices = sorted(access_indices[key])[::-1]\ncurrent_access_index = current_access_indices.pop()\nmemory[ids.range_check_ptr] = current_access_index"; @@ -335,7 +332,6 @@ mod tests { const SQUASH_DICT_INNER_NEXT_KEY: &str = "assert len(keys) > 0, 'No keys left but remaining_accesses > 0.'\nids.next_key = key = keys.pop()"; const SQUASH_DICT: &str ="dict_access_size = ids.DictAccess.SIZE\naddress = ids.dict_accesses.address_\nassert ids.ptr_diff % dict_access_size == 0, \\\n 'Accesses array size must be divisible by DictAccess.SIZE'\nn_accesses = ids.n_accesses\nif '__squash_dict_max_size' in globals():\n assert n_accesses <= __squash_dict_max_size, \\\n f'squash_dict() can only be used with n_accesses<={__squash_dict_max_size}. ' \\\n f'Got: n_accesses={n_accesses}.'\n# A map from key to the list of indices accessing it.\naccess_indices = {}\nfor i in range(n_accesses):\n key = memory[address + dict_access_size * i]\n access_indices.setdefault(key, []).append(i)\n# Descending list of keys.\nkeys = sorted(access_indices.keys(), reverse=True)\n# Are the keys used bigger than range_check bound.\nids.big_keys = 1 if keys[0] >= range_check_builtin.bound else 0\nids.first_key = key = keys.pop()"; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_valid() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //Prepare scope variables @@ -372,7 +368,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_empty_accessed_indices() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //Prepare scope variables @@ -398,7 +393,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_no_local_variables() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //No scope variables @@ -418,7 +412,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_skip_loop_valid_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_SKIP_LOOP; //Create vm @@ -437,7 +430,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_skip_loop_valid_non_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_SKIP_LOOP; //Create vm @@ -456,7 +448,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_check_access_index_valid() { let hint_code = SQUASH_DICT_INNER_CHECK_ACCESS_INDEX; //Create vm @@ -495,7 +486,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_check_access_current_access_addr_empty() { let hint_code = SQUASH_DICT_INNER_CHECK_ACCESS_INDEX; //Create vm @@ -519,7 +509,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_continue_loop_valid_non_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_CONTINUE_LOOP; //Create vm @@ -538,7 +527,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_continue_loop_valid_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_CONTINUE_LOOP; //Create vm @@ -557,7 +545,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_current_indices_len_is_empty() { let hint_code = SQUASH_DICT_INNER_ASSERT_LEN; //Create vm @@ -573,7 +560,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_current_indices_len_is_empty_not() { let hint_code = SQUASH_DICT_INNER_ASSERT_LEN; //Create vm @@ -589,7 +575,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_valid() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -613,7 +598,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_wrong_used_access_number() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -643,7 +627,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_used_access_number_relocatable() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -669,7 +652,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_empty() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -684,7 +666,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_not_empty() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -699,7 +680,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_no_keys() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -712,7 +692,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_next_key_keys_non_empty() { let hint_code = SQUASH_DICT_INNER_NEXT_KEY; //Create vm @@ -736,7 +715,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_next_key_keys_empty() { let hint_code = SQUASH_DICT_INNER_NEXT_KEY; //Create vm @@ -755,7 +733,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_no_max_size() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -787,12 +764,13 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - let access_indices_scope_value: HashMap> = - HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]); check_scope!( &exec_scopes, [ - ("access_indices", access_indices_scope_value), + ( + "access_indices", + HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]) + ), ("keys", Vec::::new()), ("key", Felt::one()) ] @@ -802,7 +780,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_two_key_dict_no_max_size() { //Dict = {1: (1,1), 1: (1,2), 2: (10,10), 2: (10,20)} let hint_code = SQUASH_DICT; @@ -840,14 +817,16 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - let access_indices_scope_value: HashMap> = HashMap::from([ - (Felt::one(), vec![Felt::zero(), Felt::one()]), - (Felt::new(2), vec![Felt::new(2), Felt::new(3)]), - ]); check_scope!( &exec_scopes, [ - ("access_indices", access_indices_scope_value), + ( + "access_indices", + HashMap::from([ + (Felt::one(), vec![Felt::zero(), Felt::one()]), + (Felt::new(2), vec![Felt::new(2), Felt::new(3)]) + ]) + ), ("keys", vec![Felt::new(2)]), ("key", Felt::one()) ] @@ -859,7 +838,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_with_max_size() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -892,12 +870,13 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - let access_indices_scope_value: HashMap> = - HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]); check_scope!( &exec_scopes, [ - ("access_indices", access_indices_scope_value), + ( + "access_indices", + HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]) + ), ("keys", Vec::::new()), ("key", Felt::one()) ] @@ -907,7 +886,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_with_max_size_exceeded() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -948,7 +926,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_bad_ptr_diff() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -983,7 +960,6 @@ mod tests { ); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_with_n_access_too_big() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -1027,7 +1003,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_no_max_size_big_keys() { //Dict = {(prime - 1): (1,1), (prime - 1): (1,2)} let hint_code = SQUASH_DICT; @@ -1071,13 +1046,10 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - let access_indices_scope_value: HashMap> = HashMap::from([( - felt_str!( - "3618502761706184546546682988428055018603476541694452277432519575032261771265" - ), - vec![Felt::zero(), Felt::one()], - )]); - check_scope!(&exec_scopes, [("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"))]); + check_scope!(&exec_scopes, [("access_indices", HashMap::from([( + felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"), + vec![Felt::zero(), Felt::one()] + )])), ("keys", Vec::::new()), ("key", felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"))]); //Check ids variables check_memory![ vm.segments.memory, diff --git a/src/hint_processor/builtin_hint_processor/uint256_utils.rs b/src/hint_processor/builtin_hint_processor/uint256_utils.rs index 155a497ec9..f358b78713 100644 --- a/src/hint_processor/builtin_hint_processor/uint256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/uint256_utils.rs @@ -1,8 +1,3 @@ -use crate::stdlib::{ - collections::HashMap, - ops::{Shl, Shr}, - prelude::*, -}; use crate::{ hint_processor::builtin_hint_processor::hint_utils::{ get_integer_from_var_name, get_relocatable_from_var_name, insert_value_from_var_name, @@ -16,6 +11,10 @@ use crate::{ use felt::Felt; use num_integer::div_rem; use num_traits::{One, Signed, Zero}; +use std::{ + collections::HashMap, + ops::{Shl, Shr}, +}; /* Implements hint: %{ @@ -241,12 +240,9 @@ mod tests { }; use assert_matches::assert_matches; use felt::felt_str; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::any::Any; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_add_ok() { let hint_code = "sum_low = ids.a.low + ids.b.low\nids.carry_low = 1 if sum_low >= ids.SHIFT else 0\nsum_high = ids.a.high + ids.b.high + ids.carry_low\nids.carry_high = 1 if sum_high >= ids.SHIFT else 0"; let mut vm = vm_with_range_check!(); @@ -268,7 +264,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_add_fail_inserts() { let hint_code = "sum_low = ids.a.low + ids.b.low\nids.carry_low = 1 if sum_low >= ids.SHIFT else 0\nsum_high = ids.a.high + ids.b.high + ids.carry_low\nids.carry_high = 1 if sum_high >= ids.SHIFT else 0"; let mut vm = vm_with_range_check!(); @@ -301,7 +296,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_ok() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -323,7 +317,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_with_big_a() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -346,7 +339,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_memory_error() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -375,7 +367,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_sqrt_ok() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -396,7 +387,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_sqrt_assert_error() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -418,7 +408,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_invalid_memory_insert() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -444,7 +433,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_result_one() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -468,7 +456,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_result_zero() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -492,7 +479,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_invalid_memory_insert() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -517,7 +503,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unsigned_div_rem_ok() { let hint_code = "a = (ids.a.high << 128) + ids.a.low\ndiv = (ids.div.high << 128) + ids.div.low\nquotient, remainder = divmod(a, div)\n\nids.quotient.low = quotient & ((1 << 128) - 1)\nids.quotient.high = quotient >> 128\nids.remainder.low = remainder & ((1 << 128) - 1)\nids.remainder.high = remainder >> 128"; let mut vm = vm_with_range_check!(); @@ -542,7 +527,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unsigned_div_rem_invalid_memory_insert() { let hint_code = "a = (ids.a.high << 128) + ids.a.low\ndiv = (ids.div.high << 128) + ids.div.low\nquotient, remainder = divmod(a, div)\n\nids.quotient.low = quotient & ((1 << 128) - 1)\nids.quotient.high = quotient >> 128\nids.remainder.low = remainder & ((1 << 128) - 1)\nids.remainder.high = remainder >> 128"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/usort.rs b/src/hint_processor/builtin_hint_processor/usort.rs index f85cbfa3a0..72c8b8d6be 100644 --- a/src/hint_processor/builtin_hint_processor/usort.rs +++ b/src/hint_processor/builtin_hint_processor/usort.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; - use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -13,6 +11,7 @@ use crate::{ }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; +use std::{any::Any, collections::HashMap}; pub fn usort_enter_scope(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { if let Ok(usort_max_size) = exec_scopes.get::("usort_max_size") { @@ -100,7 +99,7 @@ pub fn verify_usort( let value = get_integer_from_var_name("value", vm, ids_data, ap_tracking)?.clone(); let mut positions = exec_scopes .get_mut_dict_ref::>("positions_dict")? - .remove(value.as_ref()) + .remove(&value) .ok_or(HintError::UnexpectedPositionsDictFail)?; positions.reverse(); exec_scopes.insert_value("positions", positions); @@ -155,18 +154,13 @@ mod tests { }; use assert_matches::assert_matches; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn usort_with_max_size() { let mut exec_scopes = scope![("usort_max_size", 1_u64)]; assert_matches!(usort_enter_scope(&mut exec_scopes), Ok(())); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn usort_out_of_range() { let mut vm = vm_with_range_check!(); vm.run_context.fp = 2; diff --git a/src/hint_processor/hint_processor_definition.rs b/src/hint_processor/hint_processor_definition.rs index 5ba8335953..8e6bf56a47 100644 --- a/src/hint_processor/hint_processor_definition.rs +++ b/src/hint_processor/hint_processor_definition.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{any::Any, boxed::Box, collections::HashMap, prelude::*}; - use crate::any_box; use crate::serde::deserialize_program::ApTracking; use crate::serde::deserialize_program::OffsetValue; @@ -9,6 +7,8 @@ use crate::types::instruction::Register; use crate::vm::errors::hint_errors::HintError; use crate::vm::errors::vm_errors::VirtualMachineError; use crate::vm::vm_core::VirtualMachine; +use std::any::Any; +use std::collections::HashMap; use super::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; use felt::Felt; diff --git a/src/hint_processor/hint_processor_utils.rs b/src/hint_processor/hint_processor_utils.rs index 894e72be5c..0a846e8b4a 100644 --- a/src/hint_processor/hint_processor_utils.rs +++ b/src/hint_processor/hint_processor_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::borrow::Cow; - use crate::{ serde::deserialize_program::{ApTracking, OffsetValue}, types::{ @@ -9,6 +7,7 @@ use crate::{ }, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; +use std::borrow::Cow; use super::hint_processor_definition::HintReference; use felt::Felt; @@ -178,7 +177,6 @@ fn get_offset_value_reference( #[cfg(test)] mod tests { use super::*; - use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ relocatable, @@ -188,12 +186,9 @@ mod tests { }, }; use assert_matches::assert_matches; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::collections::HashMap; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_reference_with_immediate_value() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -209,7 +204,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_offset_value_reference_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -223,7 +217,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_offset_value_reference_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -237,7 +230,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_short_path() { let mut vm = vm!(); vm.segments = segments![((1, 0), (2, 0))]; @@ -253,7 +245,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_with_dereference() { let mut vm = vm!(); vm.segments = segments![((1, 0), (3, 0))]; @@ -269,7 +260,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_with_dereference_and_imm() { let mut vm = vm!(); vm.segments = segments![((1, 0), (4, 0))]; @@ -283,7 +273,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_addr_from_reference_no_regiter_in_reference() { let mut vm = vm!(); vm.segments = segments![((1, 0), (4, 0))]; @@ -294,7 +283,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_addr_from_reference_failed_to_get_ids() { let mut vm = vm!(); vm.segments = segments![((1, 0), 4)]; @@ -309,7 +297,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn tracking_correction_valid() { let mut ref_ap_tracking = ApTracking::new(); ref_ap_tracking.group = 1; @@ -323,7 +310,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn tracking_correction_invalid_group() { let mut ref_ap_tracking = ApTracking::new(); ref_ap_tracking.group = 1; @@ -339,7 +325,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_reference_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -351,7 +336,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_reference_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); diff --git a/src/lib.rs b/src/lib.rs index 021908a50a..6bfda22c3c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,52 +7,6 @@ #![cfg_attr(docsrs, feature(doc_cfg))] #![deny(warnings)] -#![cfg_attr(any(target_arch = "wasm32", not(feature = "std")), no_std)] - -#[cfg(feature = "std")] -include!("./with_std.rs"); -#[cfg(all(not(feature = "std"), feature = "alloc"))] -include!("./with_alloc.rs"); -#[cfg(not(feature = "std"))] -include!("./without_std.rs"); - -mod stdlib { - pub mod collections { - #[cfg(all(not(feature = "std"), feature = "alloc"))] - pub use crate::with_alloc::collections::*; - #[cfg(feature = "std")] - pub use crate::with_std::collections::*; - } - - pub mod borrow { - #[cfg(all(not(feature = "std"), feature = "alloc"))] - pub use crate::with_alloc::borrow::*; - #[cfg(feature = "std")] - pub use crate::with_std::borrow::*; - #[cfg(not(feature = "std"))] - pub use crate::without_std::borrow::*; - } - - pub mod prelude { - pub use crate::stdlib::{ - borrow::ToOwned, - boxed::Box, - clone::Clone, - cmp::{Eq, PartialEq, Reverse}, - iter::IntoIterator, - string::{String, ToString}, - vec::Vec, - }; - } - - #[cfg(all(not(feature = "std"), feature = "alloc"))] - pub use crate::with_alloc::*; - #[cfg(feature = "std")] - pub use crate::with_std::*; - #[cfg(not(feature = "std"))] - pub use crate::without_std::*; -} - pub mod cairo_run; pub mod hint_processor; pub mod math_utils; @@ -60,6 +14,3 @@ pub mod serde; pub mod types; pub mod utils; pub mod vm; - -#[cfg(test)] -mod tests; diff --git a/cairo-vm-cli/src/main.rs b/src/main.rs similarity index 54% rename from cairo-vm-cli/src/main.rs rename to src/main.rs index f9b05f96db..363dc933aa 100644 --- a/cairo-vm-cli/src/main.rs +++ b/src/main.rs @@ -1,14 +1,11 @@ #![deny(warnings)] -use bincode::enc::write::Writer; -use cairo_vm::cairo_run::{self, EncodeTraceError}; +use cairo_vm::cairo_run; use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use cairo_vm::vm::errors::cairo_run_errors::CairoRunError; +use cairo_vm::vm::errors::runner_errors::RunnerError; use cairo_vm::vm::errors::trace_errors::TraceError; -use cairo_vm::vm::errors::vm_errors::VirtualMachineError; use clap::{Parser, ValueHint}; -use std::io::{self, Write}; use std::path::PathBuf; -use thiserror::Error; #[cfg(feature = "with_mimalloc")] use mimalloc::MiMalloc; @@ -46,98 +43,43 @@ fn validate_layout(value: &str) -> Result<(), String> { } } -#[derive(Debug, Error)] -enum Error { - #[error("Failed to interact with the file system")] - IO(#[from] std::io::Error), - #[error("The cairo program execution failed")] - Runner(#[from] CairoRunError), - #[error(transparent)] - EncodeTrace(#[from] EncodeTraceError), - #[error(transparent)] - VirtualMachine(#[from] VirtualMachineError), -} - -struct FileWriter { - buf_writer: io::BufWriter, - bytes_written: usize, -} - -impl Writer for FileWriter { - fn write(&mut self, bytes: &[u8]) -> Result<(), bincode::error::EncodeError> { - self.buf_writer - .write_all(bytes) - .map_err(|e| bincode::error::EncodeError::Io { - inner: e, - index: self.bytes_written, - })?; - - self.bytes_written += bytes.len(); - - Ok(()) - } -} - -impl FileWriter { - fn new(buf_writer: io::BufWriter) -> Self { - Self { - buf_writer, - bytes_written: 0, - } - } - - fn flush(&mut self) -> io::Result<()> { - self.buf_writer.flush() - } -} - -fn main() -> Result<(), Error> { +fn main() -> Result<(), CairoRunError> { let args = Args::parse(); let trace_enabled = args.trace_file.is_some(); let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { entrypoint: &args.entrypoint, trace_enabled, + print_output: args.print_output, layout: &args.layout, proof_mode: args.proof_mode, secure_run: args.secure_run, }; - - let program_content = std::fs::read(args.filename).map_err(|e| Error::IO(e))?; - - let (cairo_runner, mut vm) = - match cairo_run::cairo_run(&program_content, &cairo_run_config, &mut hint_executor) { + let cairo_runner = + match cairo_run::cairo_run(&args.filename, &cairo_run_config, &mut hint_executor) { Ok(runner) => runner, Err(error) => { println!("{error}"); - return Err(Error::Runner(error)); + return Err(error); } }; - if args.print_output { - let mut output_buffer = "Program Output:\n".to_string(); - vm.write_output(&mut output_buffer)?; - print!("{output_buffer}"); - } - if let Some(trace_path) = args.trace_file { let relocated_trace = cairo_runner .relocated_trace + .as_ref() .ok_or(CairoRunError::Trace(TraceError::TraceNotEnabled))?; - - let trace_file = std::fs::File::create(trace_path)?; - let mut trace_writer = FileWriter::new(io::BufWriter::new(trace_file)); - - cairo_run::write_encoded_trace(&relocated_trace, &mut trace_writer)?; - trace_writer.flush()?; + match cairo_run::write_binary_trace(relocated_trace, &trace_path) { + Ok(()) => (), + Err(_e) => return Err(CairoRunError::Runner(RunnerError::WriteFail)), + } } if let Some(memory_path) = args.memory_file { - let memory_file = std::fs::File::create(memory_path)?; - let mut memory_writer = FileWriter::new(io::BufWriter::new(memory_file)); - - cairo_run::write_encoded_memory(&cairo_runner.relocated_memory, &mut memory_writer)?; - memory_writer.flush()?; + match cairo_run::write_binary_memory(&cairo_runner.relocated_memory, &memory_path) { + Ok(()) => (), + Err(_e) => return Err(CairoRunError::Runner(RunnerError::WriteFail)), + } } Ok(()) diff --git a/src/math_utils.rs b/src/math_utils.rs index 0efd4293b5..70633c449a 100644 --- a/src/math_utils.rs +++ b/src/math_utils.rs @@ -1,9 +1,9 @@ -use crate::stdlib::ops::Shr; use crate::types::errors::math_errors::MathError; use felt::Felt; use num_bigint::{BigInt, BigUint}; use num_integer::Integer; use num_traits::{One, Signed, Zero}; +use std::ops::Shr; ///Returns the integer square root of the nonnegative integer n. ///This is the floor of the exact square root of n. @@ -165,11 +165,7 @@ mod tests { use assert_matches::assert_matches; use num_traits::Num; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_a() { let a = bigint_str!( "11260647941622813594563746375280766662237311019551239924981511729608487775604310196863705127454617186486639011517352066501847110680463498585797912894788" @@ -190,7 +186,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_b() { let a = bigint_str!( "29642372811668969595956851264770043260610851505766181624574941701711520154703788233010819515917136995474951116158286220089597404329949295479559895970988" @@ -211,7 +206,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_c() { let a = bigint_str!( "1208267356464811040667664150251401430616174694388968865551115897173431833224432165394286799069453655049199580362994484548890574931604445970825506916876" @@ -232,7 +226,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div() { let x = Felt::new(26); let y = Felt::new(13); @@ -240,7 +233,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_non_divisor() { let x = Felt::new(25); let y = Felt::new(4); @@ -253,7 +245,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_by_zero() { let x = Felt::new(25); let y = Felt::zero(); @@ -262,13 +253,11 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize() { assert_matches!(safe_div_usize(26, 13), Ok(2)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize_non_divisor() { assert_matches!( safe_div_usize(25, 4), @@ -277,13 +266,11 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize_by_zero() { assert_matches!(safe_div_usize(25, 0), Err(MathError::DividedByZero)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_line_slope_for_valid_points() { let point_a = ( bigint_str!( @@ -311,7 +298,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_double_slope_for_valid_point_a() { let point = ( bigint_str!( @@ -332,7 +318,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_double_slope_for_valid_point_b() { let point = ( bigint_str!( @@ -353,7 +338,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_a() { let point = ( bigint_str!( @@ -379,7 +363,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_b() { let point = ( bigint_str!( @@ -405,7 +388,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_c() { let point = ( bigint_str!( @@ -431,7 +413,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_a() { let point_a = ( bigint_str!( @@ -464,7 +445,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_b() { let point_a = ( bigint_str!( @@ -497,7 +477,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_c() { let point_a = ( bigint_str!( @@ -530,21 +509,18 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_a() { let n = biguint!(81); assert_matches!(isqrt(&n), Ok(x) if x == biguint!(9)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_b() { let n = biguint_str!("4573659632505831259480"); assert_matches!(isqrt(&n.pow(2_u32)), Ok(num) if num == n); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_c() { let n = biguint_str!( "3618502788666131213697322783095070105623107215331596699973092056135872020481" @@ -553,7 +529,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_zero() { let n = BigUint::zero(); assert_matches!(isqrt(&n), Ok(inner) if inner.is_zero()); diff --git a/src/serde/deserialize_program.rs b/src/serde/deserialize_program.rs index 332964b5ec..bfe1f6deb6 100644 --- a/src/serde/deserialize_program.rs +++ b/src/serde/deserialize_program.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{collections::HashMap, fmt, prelude::*}; - use crate::{ serde::deserialize_utils, types::{ @@ -15,6 +13,7 @@ use felt::{Felt, PRIME_STR}; use num_traits::Num; use serde::{de, de::MapAccess, de::SeqAccess, Deserialize, Deserializer, Serialize}; use serde_json::Number; +use std::{collections::HashMap, fmt, io::Read}; // This enum is used to deserialize program builtins into &str and catch non-valid names #[derive(Deserialize, Debug, PartialEq)] @@ -330,22 +329,17 @@ pub fn deserialize_value_address<'de, D: Deserializer<'de>>( d.deserialize_str(ValueAddressVisitor) } -pub fn deserialize_program_json(reader: &[u8]) -> Result { - let program_json = serde_json::from_slice(reader)?; +pub fn deserialize_program_json(reader: impl Read) -> Result { + let program_json = serde_json::from_reader(reader)?; Ok(program_json) } -pub fn deserialize_and_parse_program( - reader: &[u8], + +pub fn deserialize_program( + reader: impl Read, entrypoint: Option<&str>, ) -> Result { let program_json: ProgramJson = deserialize_program_json(reader)?; - parse_program_json(program_json, entrypoint) -} -pub fn parse_program_json( - program_json: ProgramJson, - entrypoint: Option<&str>, -) -> Result { if PRIME_STR != program_json.prime { return Err(ProgramError::PrimeDiffers(program_json.prime)); } @@ -385,8 +379,8 @@ pub fn parse_program_json( let value = value .value .clone() - .ok_or_else(|| ProgramError::ConstWithoutValue(key.clone()))?; - constants.insert(key.clone(), value); + .ok_or_else(|| ProgramError::ConstWithoutValue(key.to_owned()))?; + constants.insert(key.to_owned(), value); } } @@ -415,12 +409,9 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::Zero; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::{fs::File, io::BufReader}; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_from_string_json_gives_error() { let invalid_even_length_hex_json = r#" { @@ -445,7 +436,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_invalid_char_error() { let invalid_char = r#" { @@ -458,7 +448,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_no_prefix_error() { let no_prefix = r#" { @@ -472,7 +461,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_from_string_json() { let valid_json = r#" { @@ -687,12 +675,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_a() { // Open json file with (valid) even length encoded hex - let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); + let file = File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); + let mut reader = BufReader::new(file); - let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); + let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); assert_eq!( program_json.prime, @@ -704,12 +692,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_b() { // Open json file with (valid) odd length encoded hex - let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_b.json"); + let file = File::open("cairo_programs/manually_compiled/valid_program_b.json").unwrap(); + let mut reader = BufReader::new(file); - let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); + let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); let builtins: Vec = vec![BuiltinName::output, BuiltinName::range_check]; assert_eq!( @@ -722,32 +710,33 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_gives_error() { // Open json file with (invalid) even length encoded hex - let reader = - include_bytes!("../../cairo_programs/manually_compiled/invalid_even_length_hex.json"); + let even_length_file = + File::open("cairo_programs/manually_compiled/invalid_even_length_hex.json").unwrap(); + let mut reader = BufReader::new(even_length_file); - let even_result: Result = serde_json::from_slice(reader); + let even_result: Result = serde_json::from_reader(&mut reader); assert!(even_result.is_err()); // Open json file with (invalid) odd length encoded hex - let reader = - include_bytes!("../../cairo_programs/manually_compiled/invalid_odd_length_hex.json"); + let odd_length_file = + File::open("cairo_programs/manually_compiled/invalid_odd_length_hex.json").unwrap(); + let mut reader = BufReader::new(odd_length_file); - let odd_result: Result = serde_json::from_slice(reader); + let odd_result: Result = serde_json::from_reader(&mut reader); assert!(odd_result.is_err()); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_missing_entrypoint_gives_error() { - let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); + let even_length_file = + File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); + let reader = BufReader::new(even_length_file); - let deserialization_result = - deserialize_and_parse_program(reader, Some("missing_function")); + let deserialization_result = deserialize_program(reader, Some("missing_function")); assert!(deserialization_result.is_err()); assert_matches!( deserialization_result, @@ -756,12 +745,13 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_test() { - let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); + let even_length_file = + File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); + let reader = BufReader::new(even_length_file); - let program: Program = deserialize_and_parse_program(reader, Some("main")) - .expect("Failed to deserialize program"); + let program: Program = + deserialize_program(reader, Some("main")).expect("Failed to deserialize program"); let builtins: Vec = Vec::new(); let data: Vec = vec![ @@ -818,12 +808,13 @@ mod tests { /// Deserialize a program without an entrypoint. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_without_entrypoint_test() { - let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); + let even_length_file = + File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); + let reader = BufReader::new(even_length_file); let program: Program = - deserialize_and_parse_program(reader, None).expect("Failed to deserialize program"); + deserialize_program(reader, None).expect("Failed to deserialize program"); let builtins: Vec = Vec::new(); let data: Vec = vec![ @@ -879,12 +870,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_constant() { - let reader = - include_bytes!("../../cairo_programs/manually_compiled/deserialize_constant_test.json"); + let file = + File::open("cairo_programs/manually_compiled/deserialize_constant_test.json").unwrap(); + let mut reader = BufReader::new(file); - let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); + let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); let mut identifiers: HashMap = HashMap::new(); identifiers.insert( @@ -973,7 +964,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn value_address_no_hint_reference_default_test() { let valid_json = r#" { @@ -1020,7 +1010,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_attributes_test() { let valid_json = r#" { @@ -1114,7 +1103,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_instruction_locations_test_no_parent() { let valid_json = r#" { @@ -1223,7 +1211,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_instruction_locations_test_with_parent() { let valid_json = r#" { @@ -1324,11 +1311,11 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_with_type_definition() { - let reader = include_bytes!("../../cairo_programs/uint256_integration_tests.json"); + let file = File::open("cairo_programs/uint256_integration_tests.json").unwrap(); + let reader = BufReader::new(file); - let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); + let program_json: ProgramJson = serde_json::from_reader(reader).unwrap(); assert_eq!( program_json.identifiers["starkware.cairo.common.alloc.alloc.Return"] diff --git a/src/serde/deserialize_utils.rs b/src/serde/deserialize_utils.rs index e4c659b901..22225dcdd3 100644 --- a/src/serde/deserialize_utils.rs +++ b/src/serde/deserialize_utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{fmt, num::ParseIntError, prelude::*, str::FromStr}; - use crate::{ serde::deserialize_program::{OffsetValue, ValueAddress}, types::instruction::Register, @@ -19,6 +17,7 @@ use nom::{ }; use num_integer::Integer; use parse_hyperlinks::take_until_unbalanced; +use std::{fmt, num::ParseIntError, str::FromStr}; #[derive(Debug, PartialEq, Eq)] pub enum ReferenceParseError { @@ -175,9 +174,9 @@ pub fn parse_value(input: &str) -> IResult<&str, ValueAddress> { tuple((tag(", "), take_till(|c: char| c == '*')))(second_arg)?; let type_: String = if let Some(indirections) = indirection_level.get(1..) { - struct_.to_string() + indirections + struct_.to_owned() + indirections } else { - struct_.to_string() + struct_.to_owned() }; let fst_offset = fst_offset.unwrap_or(OffsetValue::Value(0)); @@ -215,14 +214,9 @@ pub fn parse_value(input: &str) -> IResult<&str, ValueAddress> { #[cfg(test)] mod tests { use super::*; - use crate::stdlib::string::ToString; use num_traits::{One, Zero}; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn outer_brackets_test() { let deref_value = "[cast([fp])]"; let parsed_deref = outer_brackets(deref_value); @@ -234,7 +228,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn take_cast_test() { let value = "cast([fp + (-1)], felt*)"; let parsed = take_cast(value); @@ -242,7 +235,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn take_cast_first_arg_test() { let value = "cast([fp + (-1)] + (-1), felt*)"; let parsed = take_cast_first_arg(value); @@ -251,7 +243,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_register_test() { let value = "fp + (-1)"; let parsed = register(value); @@ -260,7 +251,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_offset_test() { let value_1 = " + (-1)"; let parsed_1 = offset(value_1); @@ -276,7 +266,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_register_and_offset_test() { let value_1 = "fp + 1"; let parsed_1 = register_and_offset(value_1); @@ -290,7 +279,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_inner_dereference_test() { let value = "[fp + (-1)] + 2"; let parsed = inner_dereference(value); @@ -302,7 +290,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_no_inner_dereference_test() { let value = "ap + 3"; let parsed = no_inner_dereference(value); @@ -314,7 +301,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_dereference_test() { let value = "[cast([fp + (-1)] + 2, felt*)]"; let parsed = parse_value(value); @@ -334,7 +320,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_inner_dereference_test() { let value = "cast(ap + 2, felt*)"; let parsed = parse_value(value); @@ -354,7 +339,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_register_test() { let value = "cast(825323, felt*)"; let parsed = parse_value(value); @@ -373,7 +357,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_inner_deref_and_two_offsets() { let value = "[cast(ap - 0 + (-1), felt*)]"; let parsed = parse_value(value); @@ -393,7 +376,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_and_offset2() { let value = "[cast([ap] + 1, __main__.felt*)]"; let parsed = parse_value(value); @@ -413,7 +395,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_and_immediate() { let value = "[cast([ap] + 1, felt)]"; let parsed = parse_value(value); @@ -433,7 +414,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_to_pointer() { let value = "[cast([ap + 1] + 1, felt*)]"; let parsed = parse_value(value); @@ -453,7 +433,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_2_inner_deref() { let value = "[cast([ap] + [fp + 1], __main__.felt*)]"; let parsed = parse_value(value); @@ -473,7 +452,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_2_inner_dereferences() { let value = "[cast([ap + 1] + [fp + 1], __main__.felt*)]"; let parsed = parse_value(value); @@ -493,7 +471,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_reference() { let value = "cast(825323, felt)"; let parsed = parse_value(value); @@ -513,7 +490,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_one_reference() { let value = "[cast([ap] + 1, starkware.cairo.common.cairo_secp.ec.EcPoint*)]"; let parsed = parse_value(value); @@ -533,7 +509,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_doble_reference() { let value = "[cast([ap] + 1, starkware.cairo.common.cairo_secp.ec.EcPoint**)]"; let parsed = parse_value(value); @@ -553,7 +528,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_to_felt_with_doble_reference() { let value = "[cast([ap] + [ap], felt)]"; let parsed = parse_value(value); @@ -573,7 +547,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_to_felt_with_doble_reference_and_offsets() { let value = "[cast([ap + 1] + [ap + 2], felt)]"; let parsed = parse_value(value); diff --git a/src/tests/cairo_run_test.rs b/src/tests/cairo_run_test.rs deleted file mode 100644 index 8930d3c7aa..0000000000 --- a/src/tests/cairo_run_test.rs +++ /dev/null @@ -1,1402 +0,0 @@ -use crate::stdlib::prelude::*; - -use crate::cairo_run::{self, CairoRunConfig}; -use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; - -#[cfg(target_arch = "wasm32")] -use wasm_bindgen_test::*; - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn fibonacci() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/fibonacci.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn array_sum() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/array_sum.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn big_struct() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/big_struct.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn call_function_assign_param_by_name() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/call_function_assign_param_by_name.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn function_return() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/function_return.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn function_return_if_print() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/function_return_if_print.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn function_return_to_variable() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/function_return_to_variable.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn if_and_prime() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/if_and_prime.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn if_in_function() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/if_in_function.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn if_list() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/if_list.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn jmp() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/jmp.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn jmp_if_condition() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/jmp_if_condition.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn pointers() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/pointers.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn print() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/print.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn program_return() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/return.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn reversed_register_instructions() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/reversed_register_instructions.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn simple_print() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/simple_print.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn test_addition_if() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/test_addition_if.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn test_reverse_if() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/test_reverse_if.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn test_subtraction_if() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/test_subtraction_if.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn use_imported_module() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/use_imported_module.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn bitwise_output() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/bitwise_output.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn bitwise_recursion() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/bitwise_recursion.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn integration() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/integration.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn integration_with_alloc_locals() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/integration_with_alloc_locals.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn compare_arrays() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/compare_arrays.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn compare_greater_array() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/compare_greater_array.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn compare_lesser_array() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/compare_lesser_array.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn assert_le_felt_hint() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/assert_le_felt_hint.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn assert_250_bit_element_array() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/assert_250_bit_element_array.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn abs_value_array() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/abs_value_array.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn compare_different_arrays() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/compare_different_arrays.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn assert_nn() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/assert_nn.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn sqrt() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/sqrt.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn assert_not_zero() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/assert_not_zero.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn split_int() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/split_int.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn split_int_big() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/split_int_big.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn split_felt() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/split_felt.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn math_cmp() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/math_cmp.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn unsigned_div_rem() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/unsigned_div_rem.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn signed_div_rem() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/signed_div_rem.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn assert_lt_felt() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/assert_lt_felt.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn memcpy_test() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/memcpy_test.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn memset() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/memset.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn pow() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/pow.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn dict() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/dict.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn dict_update() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/dict_update.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn uint256() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/uint256.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn find_element() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/find_element.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn search_sorted_lower() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/search_sorted_lower.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn usort() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/usort.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn squash_dict() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/squash_dict.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn dict_squash() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/dict_squash.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn set_add() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/set_add.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn secp() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/secp.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn signature() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/signature.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn secp_ec() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/secp_ec.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn blake2s_hello_world_hash() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/blake2s_hello_world_hash.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn finalize_blake2s() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/finalize_blake2s.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn unsafe_keccak() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/unsafe_keccak.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn blake2s_felts() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/blake2s_felts.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn unsafe_keccak_finalize() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/unsafe_keccak_finalize.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn keccak_add_uint256() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/keccak_add_uint256.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn keccak() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/_keccak.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn keccak_copy_inputs() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/keccak_copy_inputs.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn cairo_finalize_keccak() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/cairo_finalize_keccak.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn operations_with_data_structures() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/operations_with_data_structures.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn sha256() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/sha256.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn math_cmp_and_pow_integration_tests() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/math_cmp_and_pow_integration_tests.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn uint256_integration_tests() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/uint256_integration_tests.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn set_integration_tests() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/set_integration_tests.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn memory_integration_tests() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/memory_integration_tests.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn dict_integration_tests() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/dict_integration_tests.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn secp_integration_tests() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/secp_integration_tests.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn keccak_integration_tests() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/keccak_integration_tests.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn blake2s_integration_tests() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/blake2s_integration_tests.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn relocate_segments() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/relocate_segments.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn dict_store_cast_ptr() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/dict_store_cast_ptr.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn common_signature() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/common_signature.json"); - cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ) - .expect("Couldn't run program"); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn bad_usort() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/bad_programs/bad_usort.json"); - let expected_error_message = "unexpected verify multiplicity fail: positions length != 0"; - let res = cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ); - assert!(&res - .err() - .unwrap() - .to_string() - .contains(expected_error_message)); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn bad_dict_new() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/bad_programs/bad_dict_new.json"); - let expected_error_message = "Dict Error: Tried to create a dict whithout an initial dict"; - let res = cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ); - assert!(&res - .err() - .unwrap() - .to_string() - .contains(expected_error_message)); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn bad_dict_update() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/bad_programs/bad_dict_update.json"); - let expected_error_message = - "Dict Error: Got the wrong value for dict_update, expected value: 3, got: 5 for key: 2"; - let res = cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ); - assert!(&res - .err() - .unwrap() - .to_string() - .contains(expected_error_message)); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn error_msg_attr() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr.json"); - let expected_error_message = "SafeUint256: addition overflow"; - let res = cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ); - assert!(&res - .err() - .unwrap() - .to_string() - .contains(expected_error_message)); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn error_msg_attr_tempvar() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"); - - #[cfg(feature = "std")] - let expected_error_message = "Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n assert x = 2;\n ^***********^\n"; - #[cfg(all(not(feature = "std"), feature = "alloc"))] - let expected_error_message = "Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n"; - let res = cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ); - assert!(&res - .err() - .unwrap() - .to_string() - .contains(expected_error_message)); -} - -#[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] -fn error_msg_attr_struct() { - let mut hint_executor = BuiltinHintProcessor::new_empty(); - let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr_struct.json"); - let expected_error_message = "Error message: Cats cannot have more than nine lives: {cat} (Cannot evaluate ap-based or complex references: ['cat'])"; - let res = cairo_run::cairo_run( - file, - &CairoRunConfig { - layout: "all", - ..Default::default() - }, - &mut hint_executor, - ); - assert!(&res - .err() - .unwrap() - .to_string() - .contains(expected_error_message)); -} diff --git a/src/tests/mod.rs b/src/tests/mod.rs deleted file mode 100644 index 47c3be4d51..0000000000 --- a/src/tests/mod.rs +++ /dev/null @@ -1,7 +0,0 @@ -mod bitwise_test; -mod cairo_run_test; -mod pedersen_test; -mod struct_test; - -#[cfg(feature = "skip_next_instruction_hint")] -mod skip_instruction_test; diff --git a/src/types/errors/math_errors.rs b/src/types/errors/math_errors.rs index 9350e0eb74..bb7accb49a 100644 --- a/src/types/errors/math_errors.rs +++ b/src/types/errors/math_errors.rs @@ -1,10 +1,6 @@ use felt::Felt; use num_bigint::{BigInt, BigUint}; - -#[cfg(feature = "std")] use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; diff --git a/src/types/errors/program_errors.rs b/src/types/errors/program_errors.rs index 9a8437e7d5..c74d7456d3 100644 --- a/src/types/errors/program_errors.rs +++ b/src/types/errors/program_errors.rs @@ -1,17 +1,11 @@ -use crate::stdlib::prelude::*; - -#[cfg(feature = "std")] -use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; - use felt::PRIME_STR; +use std::io; +use thiserror::Error; #[derive(Debug, Error)] pub enum ProgramError { - #[cfg(feature = "std")] #[error(transparent)] - IO(#[from] std::io::Error), + IO(#[from] io::Error), #[error(transparent)] Parse(#[from] serde_json::Error), #[error("Entrypoint {0} not found")] @@ -26,11 +20,7 @@ pub enum ProgramError { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn format_entrypoint_not_found_error() { let error = ProgramError::EntrypointNotFound(String::from("my_function")); let formatted_error = format!("{error}"); diff --git a/src/types/exec_scope.rs b/src/types/exec_scope.rs index 941525e26b..1721d02f17 100644 --- a/src/types/exec_scope.rs +++ b/src/types/exec_scope.rs @@ -1,11 +1,10 @@ -use crate::stdlib::{any::Any, cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; use crate::{ any_box, hint_processor::builtin_hint_processor::dict_manager::DictManager, vm::errors::{exec_scope_errors::ExecScopeError, hint_errors::HintError}, }; +use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; -#[derive(Debug)] pub struct ExecutionScopes { pub data: Vec>>, } @@ -191,18 +190,13 @@ mod tests { use felt::Felt; use num_traits::One; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_execution_scopes() { let scopes = ExecutionScopes::new(); assert_eq!(scopes.data.len(), 1); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_local_variables_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -223,7 +217,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn enter_new_scope_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2_i32)); @@ -266,7 +259,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -303,7 +295,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assign_local_variable_test() { let var_value: Box = Box::new(Felt::new(2)); @@ -324,7 +315,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn re_assign_local_variable_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -350,7 +340,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn delete_local_variable_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -373,7 +362,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_main_scope_gives_error_test() { let mut scopes = ExecutionScopes::new(); @@ -381,7 +369,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_listu64_test() { let list_u64: Box = Box::new(vec![20_u64, 18_u64]); @@ -403,7 +390,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_u64_test() { let u64: Box = Box::new(9_u64); @@ -429,7 +415,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_mut_int_ref_test() { let bigint: Box = Box::new(Felt::new(12)); @@ -443,7 +428,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_any_boxed_test() { let list_u64: Box = Box::new(vec![20_u64, 18_u64]); diff --git a/src/types/instance_definitions/bitwise_instance_def.rs b/src/types/instance_definitions/bitwise_instance_def.rs index 8cea97d21b..0f1a6c5b04 100644 --- a/src/types/instance_definitions/bitwise_instance_def.rs +++ b/src/types/instance_definitions/bitwise_instance_def.rs @@ -35,25 +35,19 @@ impl BitwiseInstanceDef { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = BitwiseInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = BitwiseInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 5); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = BitwiseInstanceDef { ratio: 8, @@ -63,7 +57,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = BitwiseInstanceDef { ratio: 256, diff --git a/src/types/instance_definitions/builtins_instance_def.rs b/src/types/instance_definitions/builtins_instance_def.rs index 95be8bb98f..c29ee400b2 100644 --- a/src/types/instance_definitions/builtins_instance_def.rs +++ b/src/types/instance_definitions/builtins_instance_def.rs @@ -105,11 +105,7 @@ impl BuiltinsInstanceDef { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_plain() { let builtins = BuiltinsInstanceDef::plain(); assert!(!builtins.output); @@ -121,7 +117,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_small() { let builtins = BuiltinsInstanceDef::small(); assert!(builtins.output); @@ -133,7 +128,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_dex() { let builtins = BuiltinsInstanceDef::dex(); assert!(builtins.output); @@ -145,7 +139,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_perpetual_with_bitwise() { let builtins = BuiltinsInstanceDef::perpetual_with_bitwise(); assert!(builtins.output); @@ -157,7 +150,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_bitwise() { let builtins = BuiltinsInstanceDef::bitwise(); assert!(builtins.output); @@ -169,7 +161,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_recursive() { let builtins = BuiltinsInstanceDef::recursive(); assert!(builtins.output); @@ -181,7 +172,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_all() { let builtins = BuiltinsInstanceDef::all(); assert!(builtins.output); diff --git a/src/types/instance_definitions/cpu_instance_def.rs b/src/types/instance_definitions/cpu_instance_def.rs index 0bee2496ea..7aa89b2e17 100644 --- a/src/types/instance_definitions/cpu_instance_def.rs +++ b/src/types/instance_definitions/cpu_instance_def.rs @@ -13,11 +13,7 @@ impl CpuInstanceDef { mod tests { use super::CpuInstanceDef; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let cpu_instance = CpuInstanceDef::default(); assert!(cpu_instance._safe_call) diff --git a/src/types/instance_definitions/diluted_pool_instance_def.rs b/src/types/instance_definitions/diluted_pool_instance_def.rs index 8138c573bd..7a7f756c45 100644 --- a/src/types/instance_definitions/diluted_pool_instance_def.rs +++ b/src/types/instance_definitions/diluted_pool_instance_def.rs @@ -27,11 +27,7 @@ impl DilutedPoolInstanceDef { mod tests { use super::DilutedPoolInstanceDef; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let diluted_pool = DilutedPoolInstanceDef::default(); assert_eq!(diluted_pool.units_per_step, 16); @@ -40,7 +36,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let diluted_pool = DilutedPoolInstanceDef::new(1, 1, 1); assert_eq!(diluted_pool.units_per_step, 1); diff --git a/src/types/instance_definitions/ec_op_instance_def.rs b/src/types/instance_definitions/ec_op_instance_def.rs index f777589842..03083c6866 100644 --- a/src/types/instance_definitions/ec_op_instance_def.rs +++ b/src/types/instance_definitions/ec_op_instance_def.rs @@ -38,25 +38,19 @@ impl EcOpInstanceDef { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = EcOpInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = EcOpInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 7); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = EcOpInstanceDef { ratio: 8, @@ -67,7 +61,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = EcOpInstanceDef { ratio: 256, diff --git a/src/types/instance_definitions/ecdsa_instance_def.rs b/src/types/instance_definitions/ecdsa_instance_def.rs index 689443f682..fdd48c1d3f 100644 --- a/src/types/instance_definitions/ecdsa_instance_def.rs +++ b/src/types/instance_definitions/ecdsa_instance_def.rs @@ -41,25 +41,19 @@ impl EcdsaInstanceDef { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = EcdsaInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = EcdsaInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 2); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = EcdsaInstanceDef { ratio: 8, @@ -71,7 +65,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = EcdsaInstanceDef { ratio: 512, diff --git a/src/types/instance_definitions/keccak_instance_def.rs b/src/types/instance_definitions/keccak_instance_def.rs index d01c666622..d1bf77195e 100644 --- a/src/types/instance_definitions/keccak_instance_def.rs +++ b/src/types/instance_definitions/keccak_instance_def.rs @@ -1,5 +1,3 @@ -use crate::stdlib::prelude::*; - #[derive(Clone, Debug, PartialEq)] pub(crate) struct KeccakInstanceDef { pub(crate) _ratio: u32, @@ -40,25 +38,19 @@ impl KeccakInstanceDef { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = KeccakInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = KeccakInstanceDef::default(); assert_eq!(builtin_instance.cells_per_builtin(), 16); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = KeccakInstanceDef { _ratio: 2048, @@ -69,7 +61,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = KeccakInstanceDef { _ratio: 2048, diff --git a/src/types/instance_definitions/pedersen_instance_def.rs b/src/types/instance_definitions/pedersen_instance_def.rs index dad14cdebb..bd225d059c 100644 --- a/src/types/instance_definitions/pedersen_instance_def.rs +++ b/src/types/instance_definitions/pedersen_instance_def.rs @@ -49,25 +49,19 @@ impl PedersenInstanceDef { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = PedersenInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = PedersenInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 3); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = PedersenInstanceDef { ratio: 10, @@ -81,7 +75,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = PedersenInstanceDef { ratio: 8, diff --git a/src/types/instance_definitions/range_check_instance_def.rs b/src/types/instance_definitions/range_check_instance_def.rs index bc67866e8a..24057a7888 100644 --- a/src/types/instance_definitions/range_check_instance_def.rs +++ b/src/types/instance_definitions/range_check_instance_def.rs @@ -31,25 +31,19 @@ impl RangeCheckInstanceDef { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = RangeCheckInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 8); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = RangeCheckInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 1); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = RangeCheckInstanceDef { ratio: 10, @@ -59,7 +53,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = RangeCheckInstanceDef { ratio: 8, diff --git a/src/types/instruction.rs b/src/types/instruction.rs index d3d43866e9..f6f7590d23 100644 --- a/src/types/instruction.rs +++ b/src/types/instruction.rs @@ -103,11 +103,7 @@ pub(crate) fn is_call_instruction(encoded_instruction: &Felt, imm: Option<&Felt> mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_call_instruction_true() { let encoded_instruction = Felt::new(1226245742482522112_i64); assert!(is_call_instruction( @@ -116,14 +112,12 @@ mod tests { )); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_call_instruction_false() { let encoded_instruction = Felt::new(4612671187288031229_i64); assert!(!is_call_instruction(&encoded_instruction, None)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn instruction_size() { let encoded_instruction = Felt::new(1226245742482522112_i64); let instruction = diff --git a/src/types/layout.rs b/src/types/layout.rs index 3d9e7cebab..1e37c654a5 100644 --- a/src/types/layout.rs +++ b/src/types/layout.rs @@ -1,5 +1,3 @@ -use crate::stdlib::prelude::*; - use super::instance_definitions::{ builtins_instance_def::BuiltinsInstanceDef, cpu_instance_def::CpuInstanceDef, diluted_pool_instance_def::DilutedPoolInstanceDef, @@ -122,11 +120,7 @@ impl CairoLayout { mod tests { use super::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_plain_instance() { let layout = CairoLayout::plain_instance(); let builtins = BuiltinsInstanceDef::plain(); @@ -142,7 +136,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_small_instance() { let layout = CairoLayout::small_instance(); let builtins = BuiltinsInstanceDef::small(); @@ -158,7 +151,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_dex_instance() { let layout = CairoLayout::dex_instance(); let builtins = BuiltinsInstanceDef::dex(); @@ -174,7 +166,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perpetual_with_bitwise_instance() { let layout = CairoLayout::perpetual_with_bitwise_instance(); let builtins = BuiltinsInstanceDef::perpetual_with_bitwise(); @@ -193,7 +184,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_bitwise_instance() { let layout = CairoLayout::bitwise_instance(); let builtins = BuiltinsInstanceDef::bitwise(); @@ -212,7 +202,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_recursive_instance() { let layout = CairoLayout::recursive_instance(); let builtins = BuiltinsInstanceDef::recursive(); @@ -231,7 +220,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_all_instance() { let layout = CairoLayout::all_instance(); let builtins = BuiltinsInstanceDef::all(); diff --git a/src/types/program.rs b/src/types/program.rs index d27fc3b31e..36cbc9ad8a 100644 --- a/src/types/program.rs +++ b/src/types/program.rs @@ -1,17 +1,17 @@ -use crate::stdlib::{collections::HashMap, prelude::*}; - use crate::{ serde::deserialize_program::{ - deserialize_and_parse_program, Attribute, HintParams, Identifier, InstructionLocation, + deserialize_program, Attribute, HintParams, Identifier, InstructionLocation, ReferenceManager, }, types::{errors::program_errors::ProgramError, relocatable::MaybeRelocatable}, }; use felt::{Felt, PRIME_STR}; use serde::Serialize; - -#[cfg(feature = "std")] -use std::path::Path; +use std::{ + fs::File, + io::{BufReader, Read}, + {collections::HashMap, path::Path}, +}; #[derive(Clone, Debug, PartialEq, Eq, Serialize)] pub struct Program { @@ -54,8 +54,8 @@ impl Program { let value = value .value .clone() - .ok_or_else(|| ProgramError::ConstWithoutValue(key.clone()))?; - constants.insert(key.clone(), value); + .ok_or_else(|| ProgramError::ConstWithoutValue(key.to_owned()))?; + constants.insert(key.to_owned(), value); } } @@ -72,14 +72,18 @@ impl Program { }) } - #[cfg(feature = "std")] pub fn from_file(path: &Path, entrypoint: Option<&str>) -> Result { - let file_content = std::fs::read(path)?; - deserialize_and_parse_program(&file_content, entrypoint) + let file = File::open(path)?; + let reader = BufReader::new(file); + + deserialize_program(reader, entrypoint) } - pub fn from_bytes(bytes: &[u8], entrypoint: Option<&str>) -> Result { - deserialize_and_parse_program(bytes, entrypoint) + pub fn from_reader( + reader: impl Read, + entrypoint: Option<&str>, + ) -> Result { + deserialize_program(reader, entrypoint) } } @@ -107,15 +111,11 @@ impl Default for Program { mod tests { use super::*; use crate::serde::deserialize_program::{ApTracking, FlowTrackingData}; - use crate::utils::test_utils::*; + use crate::utils::test_utils::mayberelocatable; use felt::felt_str; use num_traits::Zero; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -151,7 +151,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new_program_with_identifiers() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -221,7 +220,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new_program_with_invalid_identifiers() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -280,13 +278,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_test() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"), + let program: Program = Program::from_file( + Path::new("cairo_programs/manually_compiled/valid_program_a.json"), Some("main"), ) - .unwrap(); + .expect("Failed to deserialize program"); let builtins: Vec<&'static str> = Vec::new(); let data: Vec = vec![ @@ -365,13 +362,12 @@ mod tests { /// Deserialize a program without an entrypoint. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_without_entrypoint_test() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"), + let program: Program = Program::from_file( + Path::new("cairo_programs/manually_compiled/valid_program_a.json"), None, ) - .unwrap(); + .expect("Failed to deserialize program"); let builtins: Vec<&'static str> = Vec::new(); @@ -465,13 +461,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_constants_test() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/manually_compiled/deserialize_constant_test.json"), + let program = Program::from_file( + Path::new("cairo_programs/manually_compiled/deserialize_constant_test.json"), Some("main"), ) - .unwrap(); + .expect("Failed to deserialize program"); let constants = [ ("__main__.compare_abs_arrays.SIZEOF_LOCALS", Felt::zero()), @@ -504,7 +499,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn default_program() { let program = Program { builtins: Vec::new(), diff --git a/src/types/relocatable.rs b/src/types/relocatable.rs index 36719ab182..2b3bae84fc 100644 --- a/src/types/relocatable.rs +++ b/src/types/relocatable.rs @@ -1,15 +1,13 @@ -use crate::stdlib::{ - fmt::{self, Display}, - ops::{Add, AddAssign, Sub}, - prelude::*, -}; - use crate::{ relocatable, types::errors::math_errors::MathError, vm::errors::memory_errors::MemoryError, }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; use serde::{Deserialize, Serialize}; +use std::{ + fmt::{self, Display}, + ops::{Add, AddAssign, Sub}, +}; #[derive(Eq, Hash, PartialEq, PartialOrd, Clone, Copy, Debug, Serialize, Deserialize)] pub struct Relocatable { @@ -356,11 +354,7 @@ mod tests { use felt::felt_str; use num_traits::{One, Zero}; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_int() { let addr = MaybeRelocatable::from(Felt::new(7i32)); let added_addr = addr.add_int(&Felt::new(2i32)); @@ -368,7 +362,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_usize_to_int() { let addr = MaybeRelocatable::from(Felt::new(7_i32)); let added_addr = addr.add_usize(2).unwrap(); @@ -376,7 +369,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_relocatable() { let addr = MaybeRelocatable::RelocatableValue(relocatable!(7, 65)); let added_addr = addr.add_int(&Felt::new(2)); @@ -390,7 +382,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_mod_offset_exceeded() { let addr = MaybeRelocatable::from((0, 0)); let error = addr.add_int(&felt_str!("18446744073709551616")); @@ -404,7 +395,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_usize_to_relocatable() { let addr = MaybeRelocatable::RelocatableValue(relocatable!(7, 65)); let added_addr = addr.add_usize(2); @@ -418,7 +408,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_int_prime_mod() { let addr = MaybeRelocatable::Int(felt_str!( "800000000000011000000000000000000000000000000000000000000000004", @@ -429,7 +418,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_relocatable_prime() { let addr = MaybeRelocatable::from((1, 9)); let added_addr = addr.add_int(&felt_str!( @@ -445,7 +433,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_int() { let addr_a = &MaybeRelocatable::from(felt_str!( "3618502788666131213697322783095070105623107215331596699973092056135872020488" @@ -456,7 +443,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocatable_to_relocatable_should_fail() { let addr_a = &MaybeRelocatable::from((7, 5)); let addr_b = &MaybeRelocatable::RelocatableValue(relocatable!(7, 10)); @@ -471,7 +457,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_relocatable() { let addr_a = &MaybeRelocatable::from((7, 7)); let addr_b = &MaybeRelocatable::from(Felt::new(10)); @@ -486,7 +471,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocatable_to_int() { let addr_a = &MaybeRelocatable::from(Felt::new(10_i32)); let addr_b = &MaybeRelocatable::RelocatableValue(relocatable!(7, 7)); @@ -501,7 +485,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_relocatable_prime() { let addr_a = &MaybeRelocatable::from((7, 14)); let addr_b = &MaybeRelocatable::Int(felt_str!( @@ -519,7 +502,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_rel_int_offset_exceeded() { let addr = MaybeRelocatable::from((0, 0)); let error = addr.add(&MaybeRelocatable::from(felt_str!("18446744073709551616"))); @@ -533,7 +515,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_int_rel_offset_exceeded() { let addr = MaybeRelocatable::Int(felt_str!("18446744073709551616")); let relocatable = Relocatable { @@ -551,7 +532,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_int_from_int() { let addr_a = &MaybeRelocatable::from(Felt::new(7)); let addr_b = &MaybeRelocatable::from(Felt::new(5)); @@ -560,7 +540,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_relocatable_from_relocatable_same_offset() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from((7, 7)); @@ -569,7 +548,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_relocatable_from_relocatable_diff_offset() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from((8, 7)); @@ -584,7 +562,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_int_addr_ref_from_relocatable_addr_ref() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from(Felt::new(5_i32)); @@ -593,7 +570,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_rel_to_int_error() { assert_eq!( MaybeRelocatable::from(Felt::new(7_i32)).sub(&MaybeRelocatable::from((7, 10))), @@ -605,7 +581,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn divmod_working() { let value = &MaybeRelocatable::from(Felt::new(10)); let div = &MaybeRelocatable::from(Felt::new(3)); @@ -615,7 +590,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn divmod_bad_type() { let value = &MaybeRelocatable::from(Felt::new(10)); let div = &MaybeRelocatable::from((2, 7)); @@ -629,7 +603,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value() { let value = MaybeRelocatable::from((2, 7)); let relocation_table = vec![1, 2, 5]; @@ -637,7 +610,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -648,7 +620,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value_with_offset() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -659,7 +630,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value_error() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -670,7 +640,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_int_value() { let value = MaybeRelocatable::from(Felt::new(7)); let relocation_table = vec![1, 2, 5]; @@ -678,7 +647,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value_no_relocation() { let value = MaybeRelocatable::from((2, 7)); let relocation_table = vec![1, 2]; @@ -689,14 +657,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_int() { assert_eq!(relocatable!(1, 2) + &Felt::new(4), Ok(relocatable!(1, 6))); assert_eq!(relocatable!(3, 2) + &Felt::zero(), Ok(relocatable!(3, 2))); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_int_mod_offset_exceeded_error() { assert_eq!( relocatable!(0, 0) + &(Felt::new(usize::MAX) + 1_usize), @@ -708,7 +674,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_i32() { let reloc = relocatable!(1, 5); @@ -727,7 +692,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mayberelocatable_try_into_reloctable() { let address = mayberelocatable!(1, 2); assert_eq!(Ok(relocatable!(1, 2)), address.try_into()); @@ -738,7 +702,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_sub_rel_test() { let reloc = relocatable!(7, 6); assert_eq!(reloc - relocatable!(7, 5), Ok(1)); @@ -749,7 +712,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_rel_different_indexes() { let a = relocatable!(7, 6); let b = relocatable!(8, 6); @@ -757,7 +719,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_ok() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(2), @@ -782,7 +743,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_add_two_relocatable_error() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(1, 2), @@ -794,7 +754,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_offset_exceeded_error() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(usize::MAX as i128 + 1), @@ -806,7 +765,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_test() { assert_eq!( mayberelocatable!(1, 2).get_relocatable(), @@ -816,7 +774,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_display() { assert_eq!( format!("{}", Relocatable::from((1, 0))), @@ -825,7 +782,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn maybe_relocatable_relocatable_display() { assert_eq!( format!("{}", MaybeRelocatable::from((1, 0))), @@ -834,7 +790,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn maybe_relocatable_int_display() { assert_eq!( format!("{}", MaybeRelocatable::from(Felt::new(6))), diff --git a/src/utils.rs b/src/utils.rs index 82721de83f..8e9db41827 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,5 +1,3 @@ -use crate::stdlib::prelude::*; - use crate::types::relocatable::Relocatable; use felt::Felt; use lazy_static::lazy_static; @@ -22,7 +20,7 @@ lazy_static! { #[macro_export] macro_rules! any_box { ($val : expr) => { - $crate::stdlib::boxed::Box::new($val) as $crate::stdlib::boxed::Box + Box::new($val) as Box }; } @@ -146,9 +144,9 @@ pub mod test_utils { let mut res = $mem.insert(k, v); while matches!(res, Err(MemoryError::UnallocatedSegment(_, _))) { if $si < 0 { - $mem.temp_data.push($crate::stdlib::vec::Vec::new()) + $mem.temp_data.push(Vec::new()) } else { - $mem.data.push($crate::stdlib::vec::Vec::new()); + $mem.data.push(Vec::new()); } res = $mem.insert(k, v); } @@ -158,9 +156,9 @@ pub mod test_utils { let mut res = $mem.insert(k, v); while matches!(res, Err(MemoryError::UnallocatedSegment(_, _))) { if $si < 0 { - $mem.temp_data.push($crate::stdlib::vec::Vec::new()) + $mem.temp_data.push(Vec::new()) } else { - $mem.data.push($crate::stdlib::vec::Vec::new()); + $mem.data.push(Vec::new()); } res = $mem.insert(k, v); } @@ -205,7 +203,7 @@ pub mod test_utils { macro_rules! references { ($num: expr) => {{ - let mut references = crate::stdlib::collections::HashMap::::new(); + let mut references = HashMap::::new(); for i in 0..$num { references.insert(i as usize, HintReference::new_simple((i as i32 - $num))); } @@ -252,17 +250,17 @@ pub mod test_utils { Program { builtins: vec![$( $builtin_name ),*], prime: "0x800000000000011000000000000000000000000000000000000000000000001".to_string(), - data: crate::stdlib::vec::Vec::new(), - constants: crate::stdlib::collections::HashMap::new(), + data: Vec::new(), + constants: HashMap::new(), main: None, start: None, end: None, - hints: crate::stdlib::collections::HashMap::new(), + hints: HashMap::new(), reference_manager: ReferenceManager { - references: crate::stdlib::vec::Vec::new(), + references: Vec::new(), }, - identifiers: crate::stdlib::collections::HashMap::new(), - error_message_attributes: crate::stdlib::vec::Vec::new(), + identifiers: HashMap::new(), + error_message_attributes: Vec::new(), instruction_locations: None, } }; @@ -303,9 +301,9 @@ pub mod test_utils { { let ids_names = vec![$( $name ),*]; let references = references!(ids_names.len() as i32); - let mut ids_data = crate::stdlib::collections::HashMap::::new(); + let mut ids_data = HashMap::::new(); for (i, name) in ids_names.iter().enumerate() { - ids_data.insert(crate::stdlib::string::ToString::to_string(name), references.get(&i).unwrap().clone()); + ids_data.insert(name.to_string(), references.get(&i).unwrap().clone()); } ids_data } @@ -316,9 +314,9 @@ pub mod test_utils { macro_rules! non_continuous_ids_data { ( $( ($name: expr, $offset:expr) ),* ) => { { - let mut ids_data = crate::stdlib::collections::HashMap::::new(); + let mut ids_data = HashMap::::new(); $( - ids_data.insert(crate::stdlib::string::String::from($name), HintReference::new_simple($offset)); + ids_data.insert(String::from($name), HintReference::new_simple($offset)); )* ids_data } @@ -367,29 +365,23 @@ pub mod test_utils { hint_processor.execute_hint(&mut $vm, $exec_scopes, &any_box!(hint_data), $constants) }}; ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr) => {{ - let hint_data = HintProcessorData::new_default( - crate::stdlib::string::ToString::to_string($hint_code), - $ids_data, - ); + let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); let mut hint_processor = BuiltinHintProcessor::new_empty(); hint_processor.execute_hint( &mut $vm, $exec_scopes, &any_box!(hint_data), - &crate::stdlib::collections::HashMap::new(), + &HashMap::new(), ) }}; ($vm:expr, $ids_data:expr, $hint_code:expr) => {{ - let hint_data = HintProcessorData::new_default( - crate::stdlib::string::ToString::to_string($hint_code), - $ids_data, - ); + let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); let mut hint_processor = BuiltinHintProcessor::new_empty(); hint_processor.execute_hint( &mut $vm, exec_scopes_ref!(), &any_box!(hint_data), - &crate::stdlib::collections::HashMap::new(), + &HashMap::new(), ) }}; } @@ -473,13 +465,13 @@ pub mod test_utils { )* let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) }; ($exec_scopes:expr, $tracker_num:expr) => { let tracker = DictTracker::new_empty(relocatable!($tracker_num, 0)); let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) }; } @@ -493,13 +485,13 @@ pub mod test_utils { )* let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) }; ($exec_scopes:expr, $tracker_num:expr,$default:expr) => { let tracker = DictTracker::new_default_dict(relocatable!($tracker_num, 0), &MaybeRelocatable::from($default), None); let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) }; } pub(crate) use dict_manager_default; @@ -521,7 +513,7 @@ pub mod test_utils { } pub(crate) use vec_data_inner; - pub fn check_scope_value( + pub fn check_scope_value( scopes: &ExecutionScopes, name: &str, value: T, @@ -533,7 +525,6 @@ pub mod test_utils { #[cfg(test)] mod test { - use crate::stdlib::{cell::RefCell, collections::HashMap, rc::Rc, string::String, vec::Vec}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -552,14 +543,11 @@ mod test { }; use felt::Felt; use num_traits::One; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; use super::*; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memory_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -582,7 +570,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -606,7 +593,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_address_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -631,7 +617,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_run_context() { let mut vm = vm!(); run_context!(vm, 2, 6, 10); @@ -642,7 +627,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_trace() { let trace = vec![ TraceEntry { @@ -699,7 +683,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_non_continuous_ids_data() { let ids_data_macro = non_continuous_ids_data![("a", -2), ("", -6)]; let ids_data_verbose = HashMap::from([ @@ -710,7 +693,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_hint_alloc() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -721,7 +703,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_scope_test_pass() { let mut exec_scopes = ExecutionScopes::new(); exec_scopes.assign_or_update_variable("a", any_box!(String::from("Hello"))); @@ -767,7 +748,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn scope_macro_test() { let scope_from_macro = scope![("a", Felt::one())]; let mut scope_verbose = ExecutionScopes::new(); @@ -781,7 +761,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_dictionary_pass() { let mut tracker = DictTracker::new_empty(relocatable!(2, 0)); tracker.insert_value( @@ -817,7 +796,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_dict_ptr_pass() { let tracker = DictTracker::new_empty(relocatable!(2, 0)); let mut dict_manager = DictManager::new(); @@ -845,7 +823,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_macro() { let tracker = DictTracker::new_empty(relocatable!(2, 0)); let mut dict_manager = DictManager::new(); @@ -859,7 +836,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_default_macro() { let tracker = DictTracker::new_default_dict( relocatable!(2, 0), @@ -877,7 +853,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn data_vec_test() { let data = vec_data!((1), ((2, 2)), (("49128305", 10)), (("3b6f00a9", 16))); assert_eq!(data[0], mayberelocatable!(1)); @@ -886,7 +861,6 @@ mod test { assert_eq!(data[3], mayberelocatable!(997130409)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_relocatable_to_indexes_test() { let reloc_1 = relocatable!(1, 5); let reloc_2 = relocatable!(0, 5); @@ -897,7 +871,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro() { let program = Program { builtins: Vec::new(), @@ -920,7 +893,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro_with_builtin() { let program = Program { builtins: vec![RANGE_CHECK_BUILTIN_NAME], @@ -943,7 +915,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro_custom_definition() { let program = Program { builtins: vec![RANGE_CHECK_BUILTIN_NAME], diff --git a/src/vm/context/run_context.rs b/src/vm/context/run_context.rs index 5a49f2a2ea..7a5839d634 100644 --- a/src/vm/context/run_context.rs +++ b/src/vm/context/run_context.rs @@ -101,18 +101,13 @@ impl RunContext { mod tests { use super::*; use crate::relocatable; - use crate::stdlib::string::ToString; use crate::types::instruction::{ApUpdate, FpUpdate, Opcode, PcUpdate, Res}; use crate::utils::test_utils::mayberelocatable; use crate::vm::errors::memory_errors::MemoryError; use assert_matches::assert_matches; use felt::Felt; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_dst_addr_for_ap_register() { let instruction = Instruction { off0: 1, @@ -141,7 +136,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_dst_addr_for_fp_register() { let instruction = Instruction { off0: 1, @@ -171,7 +165,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op0_addr_for_ap_register() { let instruction = Instruction { off0: 1, @@ -200,7 +193,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op0_addr_for_fp_register() { let instruction = Instruction { off0: 1, @@ -229,7 +221,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_fp_op1_addr() { let instruction = Instruction { off0: 1, @@ -258,7 +249,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_ap_op1_addr() { let instruction = Instruction { off0: 1, @@ -287,7 +277,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_imm_op1_addr_correct_off2() { let instruction = Instruction { off0: 1, @@ -316,7 +305,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_imm_op1_addr_incorrect_off2() { let instruction = Instruction { off0: 1, @@ -348,7 +336,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_op0_op1_addr_with_op0() { let instruction = Instruction { off0: 1, @@ -379,7 +366,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_with_no_relocatable_address() { let instruction = Instruction { off0: 1, @@ -412,7 +398,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_op0_op1_addr_without_op0() { let instruction = Instruction { off0: 1, diff --git a/src/vm/decoding/decoder.rs b/src/vm/decoding/decoder.rs index 880b478996..106e7e7a0f 100644 --- a/src/vm/decoding/decoder.rs +++ b/src/vm/decoding/decoder.rs @@ -146,14 +146,9 @@ fn decode_offset(offset: i64) -> isize { #[cfg(test)] mod decoder_test { use super::*; - use crate::stdlib::string::ToString; use assert_matches::assert_matches; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_op1_reg() { let error = decode_instruction(0x294F800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidOp1Reg(3))); @@ -164,7 +159,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_pc_update() { let error = decode_instruction(0x29A8800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidPcUpdate(3))); @@ -172,7 +166,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_res_logic() { let error = decode_instruction(0x2968800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidRes(3))); @@ -180,7 +173,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_opcode() { let error = decode_instruction(0x3948800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidOpcode(3))); @@ -188,7 +180,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_ap_update() { let error = decode_instruction(0x2D48800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidApUpdate(3))); @@ -196,7 +187,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_no_immediate_given() { assert_matches!( decode_instruction(0x14A7800080008000, None), @@ -205,7 +195,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_call_add_jmp_add_imm_fp_fp() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -224,7 +213,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_ret_add1_jmp_rel_mul_fp_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -243,7 +231,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_assrt_add_jnz_mul_ap_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -262,7 +249,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_assrt_add2_jnz_uncon_op0_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -281,7 +267,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_nop_regu_regu_op1_op0_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -300,7 +285,6 @@ mod decoder_test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_offset_negative() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 diff --git a/src/vm/errors/cairo_run_errors.rs b/src/vm/errors/cairo_run_errors.rs index 7684b29f2f..3810343411 100644 --- a/src/vm/errors/cairo_run_errors.rs +++ b/src/vm/errors/cairo_run_errors.rs @@ -1,14 +1,10 @@ -#[cfg(feature = "std")] -use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; - use super::memory_errors::MemoryError; use super::vm_exception::VmException; use crate::types::errors::program_errors::ProgramError; use crate::vm::errors::{ runner_errors::RunnerError, trace_errors::TraceError, vm_errors::VirtualMachineError, }; +use thiserror::Error; #[derive(Debug, Error)] pub enum CairoRunError { diff --git a/src/vm/errors/exec_scope_errors.rs b/src/vm/errors/exec_scope_errors.rs index 92e794a022..ec422dd32d 100644 --- a/src/vm/errors/exec_scope_errors.rs +++ b/src/vm/errors/exec_scope_errors.rs @@ -1,7 +1,4 @@ -#[cfg(feature = "std")] use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; #[derive(Eq, Hash, PartialEq, Debug, Error)] pub enum ExecScopeError { diff --git a/src/vm/errors/hint_errors.rs b/src/vm/errors/hint_errors.rs index e2ce4ec78d..5479a8944f 100644 --- a/src/vm/errors/hint_errors.rs +++ b/src/vm/errors/hint_errors.rs @@ -1,12 +1,6 @@ -use crate::stdlib::prelude::*; - -#[cfg(feature = "std")] -use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; - use felt::Felt; use num_bigint::{BigInt, BigUint}; +use thiserror::Error; use crate::types::{ errors::math_errors::MathError, diff --git a/src/vm/errors/memory_errors.rs b/src/vm/errors/memory_errors.rs index a6cf4eeb4f..afe99d6867 100644 --- a/src/vm/errors/memory_errors.rs +++ b/src/vm/errors/memory_errors.rs @@ -1,11 +1,5 @@ -use crate::stdlib::prelude::*; - -#[cfg(feature = "std")] -use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; - use felt::Felt; +use thiserror::Error; use crate::types::{ errors::math_errors::MathError, diff --git a/src/vm/errors/runner_errors.rs b/src/vm/errors/runner_errors.rs index 518fe75f14..2fe4bc0558 100644 --- a/src/vm/errors/runner_errors.rs +++ b/src/vm/errors/runner_errors.rs @@ -1,9 +1,4 @@ -use crate::stdlib::{collections::HashSet, prelude::*}; - -#[cfg(feature = "std")] -use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; +use std::collections::HashSet; use super::memory_errors::MemoryError; use crate::types::{ @@ -11,6 +6,7 @@ use crate::types::{ relocatable::{MaybeRelocatable, Relocatable}, }; use felt::Felt; +use thiserror::Error; #[derive(Debug, PartialEq, Error)] pub enum RunnerError { @@ -20,6 +16,8 @@ pub enum RunnerError { NoProgBase, #[error("Missing main()")] MissingMain, + #[error("Failed to write program output")] + WriteFail, #[error("Found None PC during VM initialization")] NoPC, #[error("Found None AP during VM initialization")] diff --git a/src/vm/errors/trace_errors.rs b/src/vm/errors/trace_errors.rs index dce825e20d..2f63144512 100644 --- a/src/vm/errors/trace_errors.rs +++ b/src/vm/errors/trace_errors.rs @@ -1,9 +1,5 @@ -#[cfg(feature = "std")] -use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; - use crate::vm::errors::memory_errors::MemoryError; +use thiserror::Error; #[derive(Debug, PartialEq, Error)] pub enum TraceError { diff --git a/src/vm/errors/vm_errors.rs b/src/vm/errors/vm_errors.rs index 2ee743d006..1f099b4f93 100644 --- a/src/vm/errors/vm_errors.rs +++ b/src/vm/errors/vm_errors.rs @@ -1,10 +1,3 @@ -use crate::stdlib::prelude::*; - -#[cfg(feature = "std")] -use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; - use crate::{ types::{ errors::math_errors::MathError, @@ -16,6 +9,8 @@ use crate::{ }, }; use felt::Felt; +use std::error::Error; +use thiserror::Error; #[derive(Debug, Error)] pub enum VirtualMachineError { @@ -115,8 +110,6 @@ pub enum VirtualMachineError { MissingAccessedAddresses, #[error(transparent)] Math(#[from] MathError), - #[error("Failed to write the output builtin content")] - FailedToWriteOutput, #[error(transparent)] - Other(anyhow::Error), + Other(Box), } diff --git a/src/vm/errors/vm_exception.rs b/src/vm/errors/vm_exception.rs index 35145deab0..070214f72f 100644 --- a/src/vm/errors/vm_exception.rs +++ b/src/vm/errors/vm_exception.rs @@ -1,13 +1,11 @@ -use crate::stdlib::{ +use std::{ fmt::{self, Display}, - prelude::*, - str, + fs::File, + io::{BufReader, Read}, + path::Path, }; -#[cfg(feature = "std")] use thiserror::Error; -#[cfg(all(not(feature = "std"), feature = "alloc"))] -use thiserror_no_std::Error; use crate::{ hint_processor::{ @@ -231,7 +229,7 @@ impl Display for VmException { impl Location { /// Prints the location with the passed message. - pub fn to_string(&self, message: &str) -> String { + pub fn to_string(&self, message: &String) -> String { let msg_prefix = if message.is_empty() { "" } else { ": " }; format!( "{}:{}:{}{}{}", @@ -239,26 +237,20 @@ impl Location { ) } - #[cfg(all(not(feature = "std"), feature = "alloc"))] - pub fn to_string_with_content(&self, message: &str) -> String { - self.to_string(message) - } - - #[cfg(feature = "std")] - pub fn to_string_with_content(&self, message: &str) -> String { + pub fn to_string_with_content(&self, message: &String) -> String { let mut string = self.to_string(message); - let input_file_path = std::path::Path::new(&self.input_file.filename); - if let Ok(file_content) = std::fs::read(input_file_path) { - string.push_str(&format!("\n{}", self.get_location_marks(&file_content))); + let input_file_path = Path::new(&self.input_file.filename); + if let Ok(file) = File::open(input_file_path) { + let mut reader = BufReader::new(file); + string.push_str(&format!("\n{}", self.get_location_marks(&mut reader))); } string } - pub fn get_location_marks(&self, file_contents: &[u8]) -> String { + pub fn get_location_marks(&self, file_contents: &mut impl Read) -> String { let mut contents = String::new(); - if let Ok(content) = str::from_utf8(file_contents) { - contents.push_str(content); - } + // If this read fails, the string will be left empty, so we can ignore the result + let _ = file_contents.read_to_string(&mut contents); let split_lines: Vec<&str> = contents.split('\n').collect(); if !(0 < self.start_line && ((self.start_line - 1) as usize) < split_lines.len()) { return String::new(); @@ -283,9 +275,8 @@ impl Location { } #[cfg(test)] mod test { - use crate::stdlib::{boxed::Box, collections::HashMap}; use assert_matches::assert_matches; - #[cfg(feature = "std")] + use std::collections::HashMap; use std::path::Path; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; @@ -296,12 +287,8 @@ mod test { use crate::types::relocatable::Relocatable; use crate::utils::test_utils::*; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - use super::*; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_vm_exception_from_vm_error() { let pc = 0; let location = Location { @@ -334,7 +321,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_no_message() { let location = Location { end_line: 2, @@ -354,7 +340,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_message() { let location = Location { end_line: 2, @@ -374,7 +359,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_location_no_attributes() { let vm_excep = VmException { pc: 2, @@ -399,7 +383,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_location_with_attributes() { let vm_excep = VmException { pc: 2, @@ -424,7 +407,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_attributes_no_parent() { let location = Location { end_line: 2, @@ -459,7 +441,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_attributes_with_parent() { let location = Location { end_line: 2, @@ -503,7 +484,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_error_attr_value_some() { let attributes = vec![Attribute { name: String::from("Error message"), @@ -522,7 +502,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_error_attr_value_none() { let attributes = vec![Attribute { name: String::from("Error message"), @@ -538,7 +517,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_some() { let location = Location { end_line: 2, @@ -561,7 +539,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_none() { let location = Location { end_line: 2, @@ -584,7 +561,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_some_hint_index() { let location_a = Location { end_line: 2, @@ -621,17 +597,12 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_bad_dict_update() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/bad_dict_update.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/bad_dict_update.json"), Some("main"), ) - .unwrap(); - #[cfg(feature = "std")] - let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n dict_update{dict_ptr=my_dict}(key=2, prev_value=3, new_value=4);\n ^*************************************************************^\n"); - #[cfg(all(not(feature = "std"), feature = "alloc"))] - let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n"); + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -641,35 +612,17 @@ mod test { assert!(cairo_runner .run_until_pc(end, &mut vm, &mut hint_processor) .is_err()); + let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n dict_update{dict_ptr=my_dict}(key=2, prev_value=3, new_value=4);\n ^*************************************************************^\n"); assert_eq!(get_traceback(&vm, &cairo_runner), Some(expected_traceback)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_bad_usort() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/bad_usort.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .unwrap(); - #[cfg(feature = "std")] - let expected_traceback = r"Cairo traceback (most recent call last): -cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) - let (output_len, output, multiplicities) = usort(input_len=3, input=input_array); - ^***********************************^ -cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) - verify_usort{output=output}( - ^**************************^ -cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) - verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value); - ^*******************************************************************************************^ -"; - #[cfg(all(not(feature = "std"), feature = "alloc"))] - let expected_traceback = r"Cairo traceback (most recent call last): -cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) -cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) -cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) -"; + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -679,14 +632,11 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) assert!(cairo_runner .run_until_pc(end, &mut vm, &mut hint_processor) .is_err()); - assert_eq!( - get_traceback(&vm, &cairo_runner), - Some(expected_traceback.to_string()) - ); + let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97)\n let (output_len, output, multiplicities) = usort(input_len=3, input=input_array);\n ^***********************************^\ncairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30)\n verify_usort{output=output}(\n ^**************************^\ncairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60)\n verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value);\n ^*******************************************************************************************^\n"); + assert_eq!(get_traceback(&vm, &cairo_runner), Some(expected_traceback)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents_no_contents() { let location = Location { end_line: 2, @@ -706,7 +656,6 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents() { let location = Location { end_line: 5, @@ -719,20 +668,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) start_col: 1, }; let message = String::from("Error at pc=0:75:"); - - #[cfg(feature = "std")] - let expected_message = "cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:\nfunc usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^"; - #[cfg(all(not(feature = "std"), feature = "alloc"))] - let expected_message = "cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:"; - assert_eq!( location.to_string_with_content(&message), - expected_message.to_string() + String::from("cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:\nfunc usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^") ) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents_no_file() { let location = Location { end_line: 5, @@ -754,7 +696,6 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] - #[cfg(feature = "std")] fn location_get_location_marks() { let location = Location { end_line: 5, @@ -767,15 +708,15 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) start_col: 1, }; let input_file_path = Path::new(&location.input_file.filename); - let file_content = std::fs::read(input_file_path).expect("Failed to open file"); + let file = File::open(input_file_path).expect("Failed to open file"); + let mut reader = BufReader::new(file); assert_eq!( - location.get_location_marks(&file_content), + location.get_location_marks(&mut reader), String::from("func usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^") ) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_get_location_marks_empty_file() { let location = Location { end_line: 5, @@ -787,14 +728,12 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) start_line: 5, start_col: 1, }; - let reader: &[u8] = &[]; - assert_eq!(location.get_location_marks(reader), String::from("")) + let mut reader: &[u8] = &[]; + assert_eq!(location.get_location_marks(&mut reader), String::from("")) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_bad_range_check_and_check_error_displayed() { - #[cfg(feature = "std")] let expected_error_string = r#"Error message: Failed range-check cairo_programs/bad_programs/bad_range_check.cairo:5:9: Error at pc=0:0: An ASSERT_EQ instruction failed: 4 != 5. @@ -814,21 +753,11 @@ cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) check_range(num - 1); ^******************^ "#; - #[cfg(all(not(feature = "std"), feature = "alloc"))] - let expected_error_string = r#"Error message: Failed range-check -cairo_programs/bad_programs/bad_range_check.cairo:5:9: Error at pc=0:0: -An ASSERT_EQ instruction failed: 4 != 5. -Cairo traceback (most recent call last): -cairo_programs/bad_programs/bad_range_check.cairo:23:5: (pc=0:29) -cairo_programs/bad_programs/bad_range_check.cairo:19:12: (pc=0:21) -cairo_programs/bad_programs/bad_range_check.cairo:19:33: (pc=0:17) -cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) -"#; - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/bad_range_check.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/bad_range_check.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -843,9 +772,7 @@ cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_bad_usort_and_check_error_displayed() { - #[cfg(feature = "std")] let expected_error_string = r#"cairo_programs/bad_programs/bad_usort.cairo:79:5: Error at pc=0:75: Got an exception while executing a hint: unexpected verify multiplicity fail: positions length != 0 %{ assert len(positions) == 0 %} @@ -861,19 +788,11 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value); ^*******************************************************************************************^ "#; - #[cfg(all(not(feature = "std"), feature = "alloc"))] - let expected_error_string = r#"cairo_programs/bad_programs/bad_usort.cairo:79:5: Error at pc=0:75: -Got an exception while executing a hint: unexpected verify multiplicity fail: positions length != 0 -Cairo traceback (most recent call last): -cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) -cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) -cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) -"#; - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/bad_usort.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -888,13 +807,12 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_value_from_simple_reference_ap_based() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); // This program uses a tempvar inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -907,13 +825,12 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn substitute_error_message_references_ap_based() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); // This program uses a tempvar inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -929,13 +846,12 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_value_from_simple_reference_complex() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_struct.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); // This program uses a struct inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -948,13 +864,12 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn substitute_error_message_references_complex() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_struct.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); // This program uses a struct inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); diff --git a/src/vm/hooks.rs b/src/vm/hooks.rs index 883e1241ff..dab0c4db39 100644 --- a/src/vm/hooks.rs +++ b/src/vm/hooks.rs @@ -9,7 +9,7 @@ //! - pre_step_instruction, executed before each instruction_step in [step](VirtualMachine::step) //! - post_step_instruction, executed after each instruction_step in [step](VirtualMachine::step) -use crate::stdlib::{any::Any, collections::HashMap, prelude::*, sync::Arc}; +use std::{any::Any, collections::HashMap, sync::Arc}; use felt::Felt; @@ -124,6 +124,8 @@ impl VirtualMachine { #[cfg(test)] mod tests { + use std::path::Path; + use super::*; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -133,11 +135,8 @@ mod tests { #[test] fn empty_hooks() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/sqrt.json"), - Some("main"), - ) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); @@ -152,11 +151,8 @@ mod tests { #[test] fn hook_failure() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/sqrt.json"), - Some("main"), - ) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) + .expect("Call to `Program::from_file()` failed."); fn before_first_step_hook( _vm: &mut VirtualMachine, @@ -222,11 +218,8 @@ mod tests { #[test] fn hook_success() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/sqrt.json"), - Some("main"), - ) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) + .expect("Call to `Program::from_file()` failed."); fn before_first_step_hook( _vm: &mut VirtualMachine, diff --git a/src/vm/runners/builtin_runner/bitwise.rs b/src/vm/runners/builtin_runner/bitwise.rs index d5d5681785..d4f5bc33ff 100644 --- a/src/vm/runners/builtin_runner/bitwise.rs +++ b/src/vm/runners/builtin_runner/bitwise.rs @@ -1,4 +1,3 @@ -use crate::stdlib::vec::Vec; use crate::{ math_utils::safe_div_usize, types::{ @@ -229,23 +228,18 @@ impl BitwiseBuiltinRunner { mod tests { use super::*; use crate::relocatable; - use crate::stdlib::collections::HashMap; use crate::vm::errors::memory_errors::MemoryError; - use crate::vm::runners::builtin_runner::BuiltinRunner; use crate::vm::runners::builtin_runner::HASH_BUILTIN_NAME; - use crate::vm::vm_core::VirtualMachine; use crate::vm::vm_memory::memory::Memory; + use crate::vm::{runners::builtin_runner::BuiltinRunner, vm_core::VirtualMachine}; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, utils::test_utils::*, vm::runners::cairo_runner::CairoRunner, }; use felt::Felt; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::collections::HashMap; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -264,7 +258,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -288,7 +281,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -316,7 +308,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), false); @@ -340,7 +331,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -364,7 +354,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true).into(); @@ -411,7 +400,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -455,7 +443,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_and() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 7), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -464,7 +451,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_xor() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 8), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -473,7 +459,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_or() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 9), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -482,7 +467,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_incorrect_offset() { let memory = memory![((0, 3), 10), ((0, 4), 12), ((0, 5), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -491,7 +475,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_no_values_to_operate() { let memory = memory![((0, 5), 12), ((0, 7), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -500,7 +483,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -508,7 +490,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -523,7 +504,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -536,7 +516,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -557,7 +536,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -572,7 +550,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -585,7 +562,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -598,7 +574,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_a() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -608,7 +583,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_b() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -618,7 +592,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_c() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), diff --git a/src/vm/runners/builtin_runner/ec_op.rs b/src/vm/runners/builtin_runner/ec_op.rs index 2b0f5973ad..152df6dd8c 100644 --- a/src/vm/runners/builtin_runner/ec_op.rs +++ b/src/vm/runners/builtin_runner/ec_op.rs @@ -1,4 +1,4 @@ -use crate::stdlib::{borrow::Cow, prelude::*}; +use std::borrow::Cow; use crate::math_utils::{ec_add, ec_double, safe_div_usize}; use crate::types::instance_definitions::ec_op_instance_def::{ @@ -325,13 +325,12 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; - use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::{test_utils::*, CAIRO_PRIME}; + use crate::vm::errors::cairo_run_errors::CairoRunError; use crate::vm::errors::vm_errors::VirtualMachineError; use crate::vm::runners::builtin_runner::HASH_BUILTIN_NAME; use crate::vm::runners::cairo_runner::CairoRunner; - use crate::vm::security::verify_secure_runner; use crate::vm::vm_memory::memory::Memory; use crate::vm::{ errors::{memory_errors::MemoryError, runner_errors::RunnerError}, @@ -339,13 +338,11 @@ mod tests { vm_core::VirtualMachine, }; use felt::felt_str; + use std::collections::HashMap; + use std::path::Path; use EcOpBuiltinRunner; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -356,7 +353,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -380,7 +376,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -408,7 +403,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), false); @@ -432,7 +426,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -456,7 +449,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true).into(); @@ -501,7 +493,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -545,7 +536,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_on_curve_a() { let x = felt_str!( "874739451078007766457464989774322083649278607533249481151382481072868806602" @@ -561,7 +551,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_on_curve_b() { let x = felt_str!( "3139037544796708144595053687182055617920475701120786241351436619796497072089" @@ -577,7 +566,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_not_on_curve_a() { let x = felt_str!( "874739454078007766457464989774322083649278607533249481151382481072868806602" @@ -593,7 +581,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_not_on_curve_b() { let x = felt_str!( "3139037544756708144595053687182055617927475701120786241351436619796497072089" @@ -609,7 +596,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_ec_op_impl_valid_a() { let partial_sum = ( felt_str!( @@ -647,7 +633,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_ec_op_impl_valid_b() { let partial_sum = ( felt_str!( @@ -685,7 +670,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] #[allow(deprecated)] fn compute_ec_op_invalid_same_x_coordinate() { let partial_sum = (Felt::one(), Felt::new(9)); @@ -715,7 +699,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Data taken from this program execution: %builtins output ec_op from starkware.cairo.common.cairo_builtins import EcOpBuiltin @@ -783,7 +766,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_unfilled_input_cells() { let memory = memory![ ( @@ -823,7 +805,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_addr_not_an_output_cell() { let memory = memory![ ( @@ -870,7 +851,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_non_integer_input() { let memory = memory![ ( @@ -915,7 +895,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -923,7 +902,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -936,7 +914,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -947,7 +924,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -966,7 +942,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -979,7 +954,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -990,7 +964,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -1001,7 +974,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stackincluded_test() { let ec_op_builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -1009,82 +981,52 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_notincluded_test() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), false); assert_eq!(ec_op_builtin.initial_stack(), Vec::new()) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn catch_point_same_x() { - let program = include_bytes!("../../../../cairo_programs/bad_programs/ec_op_same_x.json"); - let mut cairo_runner = CairoRunner::new( - &Program::from_bytes(program, Some("main")).unwrap(), - "all", - false, - ) - .unwrap(); - let mut vm = VirtualMachine::new(false); - let end = cairo_runner.initialize(&mut vm).unwrap(); - - let hint_executor = &mut BuiltinHintProcessor::new_empty(); - - cairo_runner - .run_until_pc(end, &mut vm, hint_executor) - .unwrap(); - cairo_runner - .end_run(false, false, &mut vm, hint_executor) - .unwrap(); - - vm.verify_auto_deductions().unwrap(); - cairo_runner.read_return_values(&mut vm).unwrap(); - let result = verify_secure_runner(&cairo_runner, true, &mut vm); - + let program = Path::new("cairo_programs/bad_programs/ec_op_same_x.json"); + let cairo_run_config = crate::cairo_run::CairoRunConfig { + layout: "all", + ..crate::cairo_run::CairoRunConfig::default() + }; + let result = crate::cairo_run::cairo_run( + program, + &cairo_run_config, + &mut BuiltinHintProcessor::new_empty(), + ); assert!(result.is_err()); // We need to check this way because CairoRunError doens't implement PartialEq match result { - Err(VirtualMachineError::RunnerError(RunnerError::EcOpSameXCoordinate(_))) => {} + Err(CairoRunError::VirtualMachine(VirtualMachineError::RunnerError( + RunnerError::EcOpSameXCoordinate(_), + ))) => {} Err(_) => panic!("Wrong error returned, expected RunnerError::EcOpSameXCoordinate"), Ok(_) => panic!("Expected run to fail"), } } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn catch_point_not_in_curve() { - let program = - include_bytes!("../../../../cairo_programs/bad_programs/ec_op_not_in_curve.json"); - - let mut cairo_runner = CairoRunner::new( - &Program::from_bytes(program, Some("main")).unwrap(), - "all", - false, - ) - .unwrap(); - let mut vm = VirtualMachine::new(false); - let end = cairo_runner.initialize(&mut vm).unwrap(); - - let hint_proccesor = &mut BuiltinHintProcessor::new_empty(); - cairo_runner - .run_until_pc(end, &mut vm, hint_proccesor) - .unwrap(); - - cairo_runner - .end_run(false, false, &mut vm, hint_proccesor) - .unwrap(); - - vm.verify_auto_deductions().unwrap(); - - cairo_runner.read_return_values(&mut vm).unwrap(); - - let result = verify_secure_runner(&cairo_runner, true, &mut vm); - + let program = Path::new("cairo_programs/bad_programs/ec_op_not_in_curve.json"); + let cairo_run_config = crate::cairo_run::CairoRunConfig { + layout: "all", + ..crate::cairo_run::CairoRunConfig::default() + }; + let result = crate::cairo_run::cairo_run( + program, + &cairo_run_config, + &mut BuiltinHintProcessor::new_empty(), + ); assert!(result.is_err()); - // We need to check this way because CairoRunError doens't implement PartialEq match result { - Err(VirtualMachineError::RunnerError(RunnerError::PointNotOnCurve(_))) => {} + Err(CairoRunError::VirtualMachine(VirtualMachineError::RunnerError( + RunnerError::PointNotOnCurve(_), + ))) => {} Err(_) => panic!("Wrong error returned, expected RunnerError::EcOpSameXCoordinate"), Ok(_) => panic!("Expected run to fail"), } diff --git a/src/vm/runners/builtin_runner/hash.rs b/src/vm/runners/builtin_runner/hash.rs index 226c035607..599f21363c 100644 --- a/src/vm/runners/builtin_runner/hash.rs +++ b/src/vm/runners/builtin_runner/hash.rs @@ -1,4 +1,4 @@ -use crate::stdlib::{cell::RefCell, prelude::*}; +use std::cell::RefCell; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::pedersen_instance_def::{ @@ -215,7 +215,6 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; - use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::test_utils::*; use crate::vm::runners::cairo_runner::CairoRunner; @@ -225,12 +224,9 @@ mod tests { vm_core::VirtualMachine, }; use felt::felt_str; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::collections::HashMap; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = HashBuiltinRunner::new(10, true); @@ -241,7 +237,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -265,7 +260,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -293,7 +287,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_not_included() { let mut builtin = HashBuiltinRunner::new(10, false); @@ -317,7 +310,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -341,7 +333,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = HashBuiltinRunner::new(10, true).into(); @@ -387,7 +378,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = HashBuiltinRunner::new(10, true); @@ -431,7 +421,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_valid() { let memory = memory![((0, 3), 32), ((0, 4), 72), ((0, 5), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -450,7 +439,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_incorrect_offset() { let memory = memory![((0, 4), 32), ((0, 5), 72), ((0, 6), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -459,7 +447,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_no_values_to_hash() { let memory = memory![((0, 4), 72), ((0, 5), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -468,7 +455,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_already_computed() { let memory = memory![((0, 3), 32), ((0, 4), 72), ((0, 5), 0)]; let mut builtin = HashBuiltinRunner::new(8, true); @@ -478,7 +464,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = HashBuiltinRunner::new(256, true); @@ -486,7 +471,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let vm = vm!(); @@ -498,7 +482,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -508,7 +491,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -526,7 +508,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let vm = vm!(); @@ -538,7 +519,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -548,7 +528,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 4fd7939132..39ee2ee19a 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -1,5 +1,3 @@ -use crate::stdlib::prelude::*; - use crate::hint_processor::builtin_hint_processor::keccak_utils::left_pad_u64; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::keccak_instance_def::KeccakInstanceDef; @@ -250,7 +248,6 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; - use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::test_utils::*; use crate::vm::runners::cairo_runner::CairoRunner; @@ -260,12 +257,10 @@ mod tests { runners::builtin_runner::BuiltinRunner, vm_core::VirtualMachine, }; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::collections::HashMap; + use std::path::Path; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -277,7 +272,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -301,7 +295,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -328,7 +321,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_not_included() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), false); @@ -353,7 +345,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -377,7 +368,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -385,11 +375,8 @@ mod tests { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![0]); - let program = Program::from_bytes( - include_bytes!("../../../../cairo_programs/_keccak.json"), - Some("main"), - ) - .unwrap(); + let program = + Program::from_file(Path::new("cairo_programs/_keccak.json"), Some("main")).unwrap(); let mut cairo_runner = cairo_runner!(program, "all"); @@ -408,7 +395,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -420,7 +406,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); @@ -428,7 +413,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let vm = vm!(); @@ -440,7 +424,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let mut vm = vm!(); @@ -450,7 +433,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let mut vm = vm!(); @@ -468,7 +450,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -481,7 +462,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -492,7 +472,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -503,7 +482,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stackincluded_test() { let keccak_builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); assert_eq!( @@ -513,14 +491,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_notincluded_test() { let keccak_builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), false); assert_eq!(keccak_builtin.initial_stack(), Vec::new()) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_memory_valid() { let memory = memory![ ((0, 16), 43), @@ -556,7 +532,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_non_reloc_address_err() { let memory = memory![ ((0, 4), 32), @@ -571,7 +546,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_offset_lt_input_cell_length_none() { let memory = memory![((0, 4), 32)]; let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); @@ -580,7 +554,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_offset_first_addr_error() { let memory = memory![ ((0, 16), 43), @@ -614,7 +587,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_expected_integer() { let memory = memory![((0, 0), (1, 2))]; @@ -634,7 +606,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_get_memory_err() { let memory = memory![((0, 35), 0)]; @@ -646,7 +617,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_memory_int_larger_than_bits() { let memory = memory![ ((0, 16), 43), @@ -687,7 +657,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_result() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); diff --git a/src/vm/runners/builtin_runner/mod.rs b/src/vm/runners/builtin_runner/mod.rs index c377529948..78e1b95677 100644 --- a/src/vm/runners/builtin_runner/mod.rs +++ b/src/vm/runners/builtin_runner/mod.rs @@ -1,4 +1,3 @@ -use crate::stdlib::prelude::*; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use crate::vm::errors::memory_errors::{self, MemoryError}; use crate::vm::errors::runner_errors::RunnerError; @@ -452,11 +451,7 @@ mod tests { }; use assert_matches::assert_matches; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -469,7 +464,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -480,7 +474,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -499,7 +492,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.clone().into(); @@ -507,7 +499,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.clone().into(); @@ -515,7 +506,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.clone().into(); @@ -523,7 +513,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.clone().into(); @@ -531,7 +520,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.clone().into(); @@ -539,7 +527,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -547,7 +534,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.clone().into(); @@ -555,7 +541,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.clone().into(); @@ -563,7 +548,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.clone().into(); @@ -571,7 +555,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.clone().into(); @@ -579,7 +562,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.clone().into(); @@ -587,7 +569,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -595,7 +576,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_keccak() { let keccak = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let builtin: BuiltinRunner = keccak.clone().into(); @@ -603,7 +583,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.into(); @@ -611,7 +590,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.into(); @@ -619,7 +597,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.into(); @@ -627,7 +604,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.into(); @@ -635,7 +611,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.into(); @@ -643,7 +618,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -651,7 +625,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_bitwise_with_items() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::new(10), @@ -698,7 +671,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_ec_op_with_items() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true)); @@ -742,7 +714,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_hash_with_items() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(10, true)); @@ -786,7 +757,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_range_check_with_items() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(10, 12, true)); @@ -830,7 +800,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_keccak_with_items() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::new(10, vec![200; 8]), @@ -843,7 +812,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -853,7 +821,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); let vm = vm!(); @@ -861,7 +828,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(1, true)); let vm = vm!(); @@ -869,7 +835,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -880,7 +845,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -889,7 +853,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_keccak() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -900,7 +863,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -908,7 +870,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -916,7 +877,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -924,7 +884,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -933,7 +892,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -944,7 +902,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -954,7 +911,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_keccak_zero_case() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -964,7 +920,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_keccak_non_zero_case() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -974,35 +929,30 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(16, true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses_test() { let bitwise_builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1023,7 +973,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_for_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -1032,7 +981,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_empty_memory() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -1044,7 +992,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_empty_offsets() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -1058,7 +1005,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_bitwise_missing_memory_cells_with_offsets() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -1081,7 +1027,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_bitwise_missing_memory_cells() { let mut bitwise_builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -1109,7 +1054,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_hash_missing_memory_cells_with_offsets() { let builtin: BuiltinRunner = HashBuiltinRunner::new(8, true).into(); let mut vm = vm!(); @@ -1130,7 +1074,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_hash_missing_memory_cells() { let hash_builtin = HashBuiltinRunner::new(8, true); @@ -1149,7 +1092,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_missing_memory_cells_with_offsets() { let range_check_builtin = RangeCheckBuiltinRunner::new(8, 8, true); let builtin: BuiltinRunner = range_check_builtin.into(); @@ -1173,7 +1115,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_missing_memory_cells() { let builtin: BuiltinRunner = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); @@ -1190,7 +1131,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_empty() { let range_check_builtin = RangeCheckBuiltinRunner::new(8, 8, true); @@ -1204,7 +1144,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_validate_auto_deductions() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1227,7 +1166,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_empty() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1241,7 +1179,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_1_element() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1259,7 +1196,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_3_elements() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1278,7 +1214,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_missing_memory_cells_with_offsets() { let builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -1301,7 +1236,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_gap() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1334,7 +1268,6 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is a BitwiseBuiltinRunner. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_bitwise() { let builtin_runner: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1348,7 +1281,6 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is an EcOpBuiltinRunner. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_ec_op() { let builtin_runner: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -1362,7 +1294,6 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is a HashBuiltinRunner. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_hash() { let builtin_runner: BuiltinRunner = HashBuiltinRunner::new(8, true).into(); let mut vm = vm!(); @@ -1375,7 +1306,6 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is an OutputBuiltinRunner. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_output() { let builtin_runner: BuiltinRunner = OutputBuiltinRunner::new(true).into(); let mut vm = vm!(); @@ -1388,7 +1318,6 @@ mod tests { /// Test that get_used_perm_range_check_units() calls the corresponding /// method when the builtin is a RangeCheckBuiltinRunner. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_range_check() { let builtin_runner: BuiltinRunner = RangeCheckBuiltinRunner::new(8, 8, true).into(); let mut vm = vm!(); @@ -1399,7 +1328,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ratio_tests() { let bitwise_builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1420,7 +1348,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn bitwise_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1431,7 +1358,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn ec_op_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1442,7 +1368,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn hash_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1452,7 +1377,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn output_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1461,7 +1385,6 @@ mod tests { assert_eq!(output_builtin.get_used_instances(&vm.segments), Ok(4)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn range_check_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1472,7 +1395,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn runners_final_stack() { let mut builtins = vec![ BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( @@ -1500,7 +1422,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn runners_set_stop_ptr() { let builtins = vec![ BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( diff --git a/src/vm/runners/builtin_runner/output.rs b/src/vm/runners/builtin_runner/output.rs index 131d23c4ee..618faa0f1a 100644 --- a/src/vm/runners/builtin_runner/output.rs +++ b/src/vm/runners/builtin_runner/output.rs @@ -1,4 +1,3 @@ -use crate::stdlib::prelude::*; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use crate::vm::errors::memory_errors::MemoryError; use crate::vm::errors::runner_errors::RunnerError; @@ -127,7 +126,6 @@ impl Default for OutputBuiltinRunner { mod tests { use super::*; use crate::relocatable; - use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory::Memory; use crate::{ utils::test_utils::*, @@ -136,12 +134,9 @@ mod tests { vm_core::VirtualMachine, }, }; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::collections::HashMap; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = OutputBuiltinRunner::new(true); @@ -152,7 +147,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = OutputBuiltinRunner::new(true); @@ -176,7 +170,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = OutputBuiltinRunner::new(true); @@ -204,7 +197,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = OutputBuiltinRunner::new(false); @@ -228,7 +220,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = OutputBuiltinRunner::new(true); @@ -252,7 +243,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = OutputBuiltinRunner::new(true).into(); @@ -267,7 +257,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = OutputBuiltinRunner::new(true); @@ -277,7 +266,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_output() { let mut builtin = OutputBuiltinRunner::new(true); let mut segments = MemorySegmentManager::new(); @@ -286,7 +274,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_output_with_base() { let mut builtin = OutputBuiltinRunner::new(true); builtin.base = 1; @@ -299,7 +286,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = OutputBuiltinRunner::new(true); @@ -307,7 +293,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -319,7 +304,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -329,7 +313,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -347,7 +330,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -359,7 +341,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -369,7 +350,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -379,7 +359,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_used_instances_missing_segments() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let memory_segment_manager = MemorySegmentManager::new(); @@ -391,7 +370,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_used_instances_valid() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut memory_segment_manager = MemorySegmentManager::new(); @@ -401,7 +379,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_deduce_memory_cell_output_builtin() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -424,7 +401,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_add_validation_rule() { let builtin = OutputBuiltinRunner::new(true); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/range_check.rs b/src/vm/runners/builtin_runner/range_check.rs index 7eb286a570..edb5e34f46 100644 --- a/src/vm/runners/builtin_runner/range_check.rs +++ b/src/vm/runners/builtin_runner/range_check.rs @@ -1,9 +1,3 @@ -use crate::stdlib::{ - cmp::{max, min}, - ops::Shl, - prelude::*, -}; - use crate::{ math_utils::safe_div_usize, types::{ @@ -25,6 +19,10 @@ use crate::{ use felt::Felt; use num_integer::Integer; use num_traits::{One, ToPrimitive, Zero}; +use std::{ + cmp::{max, min}, + ops::Shl, +}; use super::RANGE_CHECK_BUILTIN_NAME; @@ -250,7 +248,6 @@ impl RangeCheckBuiltinRunner { mod tests { use super::*; use crate::relocatable; - use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory::Memory; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -261,12 +258,9 @@ mod tests { vm_core::VirtualMachine, }, }; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::collections::HashMap; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -277,7 +271,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -301,7 +294,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -329,7 +321,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, false); @@ -353,7 +344,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -377,7 +367,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = RangeCheckBuiltinRunner::new(10, 12, true).into(); @@ -423,7 +412,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -467,7 +455,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_range_check() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -476,7 +463,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_range_check_with_base() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); builtin.base = 1; @@ -489,7 +475,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); @@ -497,7 +482,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let vm = vm!(); @@ -509,7 +493,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -519,7 +502,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -537,21 +519,18 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_base() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); assert_eq!(builtin.base(), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_ratio() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); assert_eq!(builtin.ratio(), 8); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let vm = vm!(); @@ -563,7 +542,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -573,7 +551,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -583,7 +560,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_a() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -591,7 +567,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_b() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![ @@ -604,7 +579,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_c() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![ @@ -619,7 +593,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_empty_memory() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = Memory::new(); @@ -628,7 +601,6 @@ mod tests { /// Test that the method get_used_perm_range_check_units works as intended. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units() { let builtin_runner = RangeCheckBuiltinRunner::new(8, 8, true); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/signature.rs b/src/vm/runners/builtin_runner/signature.rs index b9c29f7c33..1095de4a93 100644 --- a/src/vm/runners/builtin_runner/signature.rs +++ b/src/vm/runners/builtin_runner/signature.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; - use crate::{ math_utils::safe_div_usize, types::{ @@ -21,6 +19,7 @@ use crate::{ use felt::Felt; use num_integer::div_ceil; use starknet_crypto::{verify, FieldElement, Signature}; +use std::{cell::RefCell, collections::HashMap, rc::Rc}; use super::SIGNATURE_BUILTIN_NAME; @@ -271,11 +270,7 @@ mod tests { }, }; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_min_step_not_reached() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -290,7 +285,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_valid() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let mut vm = vm!(); @@ -300,7 +294,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_ecdsa() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut segments = MemorySegmentManager::new(); @@ -309,7 +302,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin: BuiltinRunner = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true).into(); @@ -321,7 +313,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -345,7 +336,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -373,7 +363,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -397,7 +386,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -405,7 +393,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -420,7 +407,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -433,7 +419,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -454,7 +439,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -469,7 +453,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -482,7 +465,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -495,7 +477,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_range_check_with_base() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); builtin.base = 1; @@ -508,14 +489,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_not_included_test() { let ecdsa_builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), false); assert_eq!(ecdsa_builtin.initial_stack(), Vec::new()) } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_test() { let memory = Memory::new(); let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -524,21 +503,18 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_ratio() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); assert_eq!(builtin.ratio(), 512); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_base() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); assert_eq!(builtin.base(), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_memory_segment_addresses() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -546,7 +522,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell() { let memory = Memory::new(); let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -555,7 +530,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_safe_div_fail() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -567,7 +541,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_safe_div_fail() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -586,7 +559,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_insufficient_allocated() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -601,7 +573,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_invalid_stop_pointer() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -617,7 +588,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_no_used_instances() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index 4eeac14a8e..8f210c33dd 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -1,10 +1,3 @@ -use crate::stdlib::{ - any::Any, - collections::{HashMap, HashSet}, - ops::{Add, Sub}, - prelude::*, -}; - use crate::{ hint_processor::hint_processor_definition::{HintProcessor, HintReference}, math_utils::safe_div_usize, @@ -46,6 +39,12 @@ use crate::{ use felt::Felt; use num_integer::div_rem; use num_traits::Zero; +use std::{ + any::Any, + collections::{HashMap, HashSet}, + io, + ops::{Add, Sub}, +}; use super::builtin_runner::{ KeccakBuiltinRunner, BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, @@ -71,7 +70,6 @@ impl From> for CairoArg { } } -#[derive(Debug)] pub struct CairoRunner { pub(crate) program: Program, layout: CairoLayout, @@ -240,7 +238,6 @@ impl CairoRunner { self.layout._name.clone(), )); } - drop(inserted_builtins); vm.builtin_runners = builtin_runners; Ok(()) @@ -838,6 +835,50 @@ impl CairoRunner { }) } + pub fn get_output(&mut self, vm: &mut VirtualMachine) -> Result { + let mut output = Vec::::new(); + self.write_output(vm, &mut output)?; + let output = String::from_utf8(output).map_err(|_| RunnerError::FailedStringConversion)?; + Ok(output) + } + + /// Writes the values hosted in the output builtin's segment. + /// Does nothing if the output builtin is not present in the program. + pub fn write_output( + &mut self, + vm: &mut VirtualMachine, + stdout: &mut dyn io::Write, + ) -> Result<(), RunnerError> { + let (_, builtin) = match vm + .builtin_runners + .iter() + .find(|(k, _)| k == &OUTPUT_BUILTIN_NAME) + { + Some(x) => x, + _ => return Ok(()), + }; + + let segment_used_sizes = vm.segments.compute_effective_sizes(); + let segment_index = builtin.base(); + #[allow(deprecated)] + for i in 0..segment_used_sizes[segment_index] { + let formatted_value = match vm + .segments + .memory + .get(&Relocatable::from((segment_index as isize, i))) + { + Some(val) => match val.as_ref() { + MaybeRelocatable::Int(num) => format!("{}", num.to_bigint()), + MaybeRelocatable::RelocatableValue(rel) => format!("{}", rel), + }, + _ => "".to_string(), + }; + writeln!(stdout, "{formatted_value}").map_err(|_| RunnerError::WriteFail)?; + } + + Ok(()) + } + // Finalizes the segments. // Note: // 1. end_run() must precede a call to this method. @@ -1161,7 +1202,6 @@ impl Sub for ExecutionResources { #[cfg(test)] mod tests { use super::*; - use crate::stdlib::collections::{HashMap, HashSet}; use crate::vm::vm_memory::memory::MemoryCell; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ @@ -1175,12 +1215,12 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::One; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::{ + collections::{HashMap, HashSet}, + path::Path, + }; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_usage_ok_case() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; @@ -1192,7 +1232,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_usage_err_case() { let program = program!(); @@ -1216,7 +1255,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_builtins_with_disordered_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; @@ -1226,7 +1264,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_cairo_runner_with_ordered_but_missing_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME]; @@ -1235,7 +1272,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_with_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1269,7 +1305,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_no_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1298,7 +1333,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_empty_data_and_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1319,7 +1353,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_some_data_empty_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!( @@ -1342,7 +1375,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_empty_data_some_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1359,7 +1391,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_no_program_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1398,7 +1429,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_entrypoint_empty_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1420,7 +1450,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_entrypoint_some_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -1471,7 +1500,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(main = Some(1),); @@ -1484,16 +1512,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_program_segment_accessed_addrs() { // This test checks that all addresses from the program segment are marked as accessed at VM state initialization. // The fibonacci program has 24 instructions, so there should be 24 accessed addresses, // from (0, 0) to (0, 23). - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/fibonacci.json"), - Some("main"), - ) - .unwrap(); + let program = Program::from_file(Path::new("cairo_programs/fibonacci.json"), Some("main")) + .expect("Call to `Program::from_file()` failed."); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); @@ -1508,7 +1532,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_no_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(main = Some(1),); @@ -1525,7 +1548,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_with_range_check_valid() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(builtins = vec![RANGE_CHECK_BUILTIN_NAME], main = Some(1),); @@ -1554,7 +1576,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_with_range_check_invalid() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(builtins = vec![RANGE_CHECK_BUILTIN_NAME], main = Some(1),); @@ -1578,7 +1599,6 @@ mod tests { //Integration tests for initialization phase #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: func myfunc(a: felt) -> (r: felt): let b = a * 2 @@ -1649,7 +1669,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -1727,7 +1746,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -1822,7 +1840,6 @@ mod tests { //Integration tests for initialization + execution phase #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: func myfunc(a: felt) -> (r: felt): let b = a * 2 @@ -1892,7 +1909,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -1993,7 +2009,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2106,7 +2121,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output range_check @@ -2266,7 +2280,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Memory from this test is taken from a cairo program execution Program used: func main(): @@ -2366,7 +2379,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output @@ -2522,7 +2534,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output @@ -2690,8 +2701,7 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn get_output_from_preset_memory() { + fn write_output_from_preset_memory() { let program = program![OUTPUT_BUILTIN_NAME]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); @@ -2702,14 +2712,12 @@ mod tests { vm.segments = segments![((2, 0), 1), ((2, 1), 2)]; vm.segments.segment_used_sizes = Some(vec![0, 0, 2]); - - let mut output_buffer = String::new(); - vm.write_output(&mut output_buffer).unwrap(); - assert_eq!(&output_buffer, "1\n2\n"); + let mut stdout = Vec::::new(); + cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); + assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n2\n"))); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2720,7 +2728,7 @@ mod tests { serialize_word(a) return() end */ - fn get_output_from_program() { + fn write_output_from_program() { //Initialization Phase let program = program!( builtins = vec![OUTPUT_BUILTIN_NAME], @@ -2761,13 +2769,12 @@ mod tests { Ok(()) ); - let mut output_buffer = String::new(); - vm.write_output(&mut output_buffer).unwrap(); - assert_eq!(&output_buffer, "1\n17\n"); + let mut stdout = Vec::::new(); + cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); + assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n17\n"))); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2802,14 +2809,16 @@ mod tests { Ok(()) ); - let mut output_buffer = String::new(); - vm.write_output(&mut output_buffer).unwrap(); - assert_eq!(&output_buffer, "\n2:0\n"); + let mut stdout = Vec::::new(); + cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); + assert_eq!( + String::from_utf8(stdout), + Ok(String::from("\n2:0\n")) + ); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn get_output_from_preset_memory_neg_output() { + fn write_output_from_preset_memory_neg_output() { let program = program![OUTPUT_BUILTIN_NAME]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); @@ -2825,16 +2834,14 @@ mod tests { ) )]; vm.segments.segment_used_sizes = Some(vec![0, 0, 1]); - - let mut output_buffer = String::new(); - vm.write_output(&mut output_buffer).unwrap(); - assert_eq!(&output_buffer, "-1\n"); + let mut stdout = Vec::::new(); + cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); + assert_eq!(String::from_utf8(stdout), Ok(String::from("-1\n"))); } - /// Test that `get_output()` works when the `output` builtin is not the first one. + /// Test that `write_output()` works when the `output` builtin is not the first one. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn get_output_unordered_builtins() { + fn write_output_unordered_builtins() { //Initialization Phase let program = program!( builtins = vec![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME], @@ -2888,13 +2895,14 @@ mod tests { Ok(()) ); - let mut output_buffer = String::new(); - vm.write_output(&mut output_buffer).unwrap(); - assert_eq!(&output_buffer, "1\n17\n"); + let mut stdout = Vec::::new(); + cairo_runner + .write_output(&mut vm, &mut stdout) + .expect("Call to `write_output()` failed."); + assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n17\n"))); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_all_builtins_in_order() { let program = program![ OUTPUT_BUILTIN_NAME, @@ -2914,7 +2922,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -2981,7 +2988,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -3052,7 +3058,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -3162,7 +3167,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_constants() { let program_constants = HashMap::from([ ("MAX".to_string(), Felt::new(300)), @@ -3174,7 +3178,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_missing_segment_used_sizes() { let program = program!(); @@ -3192,7 +3195,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty() { let program = program!(); @@ -3205,7 +3207,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty_builtins() { let program = program!(); @@ -3220,7 +3221,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty_accesses() { let program = program!(); @@ -3238,7 +3238,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes() { let program = program!(); @@ -3260,7 +3259,6 @@ mod tests { /// Test that check_diluted_check_usage() works without a diluted pool /// instance. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_without_pool_instance() { let program = program!(); @@ -3273,7 +3271,6 @@ mod tests { /// Test that check_diluted_check_usage() works without builtin runners. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_without_builtin_runners() { let program = program!(); @@ -3288,7 +3285,6 @@ mod tests { /// Test that check_diluted_check_usage() fails when there aren't enough /// allocated units. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_insufficient_allocated_cells() { let program = program!(); @@ -3308,7 +3304,6 @@ mod tests { /// Test that check_diluted_check_usage() succeeds when all the conditions /// are met. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage() { let program = program!(); @@ -3324,7 +3319,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_run_already_finished() { let program = program!(); @@ -3342,7 +3336,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run() { let program = program!(); @@ -3365,13 +3358,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_proof_mode_insufficient_allocated_cells() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/proof_programs/fibonacci.json"), + let program = Program::from_file( + Path::new("cairo_programs/proof_programs/fibonacci.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", true); @@ -3388,7 +3380,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtin_segments_info_empty() { let program = program!(); @@ -3399,7 +3390,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtin_segments_info_base_not_finished() { let program = program!(); @@ -3417,7 +3407,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources_trace_not_enabled() { let program = program!(); @@ -3436,7 +3425,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources_empty_builtins() { let program = program!(); @@ -3456,7 +3444,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources() { let program = program!(); @@ -3482,7 +3469,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_not_ended() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3494,7 +3480,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_no_prog_base() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3508,7 +3493,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_no_exec_base() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3523,7 +3507,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_noproof_mode() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3538,7 +3521,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_emptyproof_mode() { let program = program!(); let mut cairo_runner = cairo_runner!(program, "plain", true); @@ -3552,7 +3534,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_not_emptyproof_mode_empty_execution_public_memory() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -3585,7 +3566,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_not_emptyproof_mode_with_execution_public_memory() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4)]; @@ -3625,7 +3605,6 @@ mod tests { /// Test that ensures get_perm_range_check_limits() returns an error when /// trace is not enabled. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_trace_not_enabled() { let program = program!(); @@ -3643,7 +3622,6 @@ mod tests { /// Test that ensures get_perm_range_check_limits() returns None when the /// trace is empty (get_perm_range_check_limits returns None). #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_empty() { let program = program!(); @@ -3657,7 +3635,6 @@ mod tests { /// Test that get_perm_range_check_limits() works correctly when there are /// no builtins. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_no_builtins() { let program = program!(); @@ -3696,7 +3673,6 @@ mod tests { /// Test that get_perm_range_check_limits() works correctly when there are /// builtins. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits() { let program = program!(); @@ -3725,7 +3701,6 @@ mod tests { /// Test that check_range_check_usage() returns successfully when trace is /// not enabled. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_perm_range_limits_none() { let program = program!(); @@ -3739,7 +3714,6 @@ mod tests { /// Test that check_range_check_usage() returns successfully when all the /// conditions are met. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_without_builtins() { let program = program!(); @@ -3762,7 +3736,6 @@ mod tests { /// Test that check_range_check_usage() returns an error if there are /// insufficient allocated cells. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_insufficient_allocated_cells() { let program = program!(); @@ -3790,7 +3763,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_fp_is_none_without_initialization() { let program = program!(); @@ -3800,7 +3772,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_fp_can_be_obtained() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![OUTPUT_BUILTIN_NAME]; @@ -3819,7 +3790,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_valid_case() { let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; let mut cairo_runner = cairo_runner!(program); @@ -3832,7 +3802,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_get_used_cells_and_allocated_size_error() { let program = program!(); @@ -3860,7 +3829,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_check_memory_usage_error() { let program = program!(); @@ -3886,7 +3854,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_check_diluted_check_usage_error() { let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; let cairo_runner = cairo_runner!(program); @@ -3903,7 +3870,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_all_builtins() { let program = program!(); @@ -3926,7 +3892,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_all_builtins_maintain_program_order() { let program = program![ HASH_BUILTIN_NAME, @@ -3953,7 +3918,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_runner() { let program = program!(); @@ -3992,7 +3956,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_plain_one_builtin() { let program = program![OUTPUT_BUILTIN_NAME]; let mut vm = vm!(); @@ -4007,7 +3970,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_plain_two_builtins() { let program = program![OUTPUT_BUILTIN_NAME, HASH_BUILTIN_NAME]; let mut vm = vm!(); @@ -4022,7 +3984,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_small_two_builtins() { let program = program![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME]; let mut vm = vm!(); @@ -4036,7 +3997,6 @@ mod tests { ); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint_proof_mode_empty_program() { let program = program!(start = Some(0), end = Some(0), main = Some(8),); let mut runner = cairo_runner!(program); @@ -4055,7 +4015,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint_proof_mode_empty_program_two_builtins() { let program = program!( start = Some(0), @@ -4080,7 +4039,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn can_get_the_runner_program_builtins() { let program = program!( start = Some(0), @@ -4094,7 +4052,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main_default() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4121,7 +4078,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4162,7 +4118,6 @@ mod tests { /// Test that set_entrypoint() fails when the entrypoint doesn't exist. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main_non_existent() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4189,7 +4144,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4212,7 +4166,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test_with_run_not_ended() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4229,7 +4182,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test_with_segments_finalized() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4247,7 +4199,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_one_builtin_empty() { let mut program = program![OUTPUT_BUILTIN_NAME]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4278,7 +4229,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_one_builtin_one_element() { let mut program = program![OUTPUT_BUILTIN_NAME]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4309,7 +4259,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_two_builtins() { let mut program = program![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4355,7 +4304,6 @@ mod tests { /// Test that add_additional_hash_builtin() creates an additional builtin. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_additional_hash_builtin() { let program = program!(); let cairo_runner = cairo_runner!(program); @@ -4383,7 +4331,6 @@ mod tests { /// Test that add_additional_hash_builtin() replaces the created runner if called multiple /// times. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_additional_hash_builtin_replace() { let program = program!(); let cairo_runner = cairo_runner!(program); @@ -4410,13 +4357,9 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_from_entrypoint_custom_program_test() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/example_program.json"), - None, - ) - .unwrap(); + let program = + Program::from_file(Path::new("cairo_programs/example_program.json"), None).unwrap(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(true); //this true expression dictates that the trace is enabled let mut hint_processor = BuiltinHintProcessor::new_empty(); @@ -4475,7 +4418,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_arg_from_single() { let expected = CairoArg::Single(MaybeRelocatable::from((0, 0))); let value = MaybeRelocatable::from((0, 0)); @@ -4483,7 +4425,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_arg_from_array() { let expected = CairoArg::Array(vec![MaybeRelocatable::from((0, 0))]); let value = vec![MaybeRelocatable::from((0, 0))]; @@ -4491,7 +4432,7 @@ mod tests { } fn setup_execution_resources() -> (ExecutionResources, ExecutionResources) { - let mut builtin_instance_counter: HashMap = HashMap::new(); + let mut builtin_instance_counter: HashMap = HashMap::new(); builtin_instance_counter.insert(OUTPUT_BUILTIN_NAME.to_string(), 8); let execution_resources_1 = ExecutionResources { @@ -4513,7 +4454,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn execution_resources_add() { let (execution_resources_1, execution_resources_2) = setup_execution_resources(); let combined_resources = execution_resources_1 + execution_resources_2; @@ -4533,7 +4473,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn execution_resources_sub() { let (execution_resources_1, execution_resources_2) = setup_execution_resources(); @@ -4554,10 +4493,9 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_from_entrypoint_substitute_error_message_test() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/bad_programs/error_msg_function.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/error_msg_function.json"), None, ) .unwrap(); @@ -4596,10 +4534,9 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_range_check_builtin() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/assert_le_felt_hint.json"), + let program = Program::from_file( + Path::new("cairo_programs/assert_le_felt_hint.json"), Some("main"), ) .unwrap(); @@ -4619,13 +4556,9 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_4_builtins() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/integration.json"), - Some("main"), - ) - .unwrap(); + let program = + Program::from_file(Path::new("cairo_programs/integration.json"), Some("main")).unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); @@ -4642,13 +4575,9 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_no_builtins() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/fibonacci.json"), - Some("main"), - ) - .unwrap(); + let program = + Program::from_file(Path::new("cairo_programs/fibonacci.json"), Some("main")).unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); @@ -4665,14 +4594,10 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn filter_unused_builtins_test() { - let program = Program::from_bytes( - include_bytes!("../../../cairo_programs/integration.json"), - Some("main"), - ) - .unwrap(); + let program = + Program::from_file(Path::new("cairo_programs/integration.json"), Some("main")).unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); diff --git a/src/vm/security.rs b/src/vm/security.rs index 12cb2689e7..0ad3d994ed 100644 --- a/src/vm/security.rs +++ b/src/vm/security.rs @@ -1,5 +1,3 @@ -use crate::stdlib::prelude::*; - use num_traits::ToPrimitive; use super::{ @@ -83,7 +81,6 @@ pub fn verify_secure_runner( mod test { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; - use crate::stdlib::collections::HashMap; use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; use crate::vm::errors::memory_errors::MemoryError; @@ -94,12 +91,9 @@ mod test { use assert_matches::assert_matches; use felt::Felt; use num_traits::Zero; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::collections::HashMap; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_without_program_base() { let program = program!(); @@ -113,7 +107,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_empty_memory() { let program = program!(main = Some(0),); @@ -126,7 +119,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_program_access_out_of_bounds() { let program = program!(main = Some(0),); @@ -145,7 +137,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_builtin_access_out_of_bounds() { let program = program!(main = Some(0), builtins = vec![RANGE_CHECK_BUILTIN_NAME],); @@ -163,7 +154,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_builtin_access_correct() { let program = program!(main = Some(0), builtins = vec![RANGE_CHECK_BUILTIN_NAME],); @@ -183,7 +173,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_success() { let program = program!( data = vec![ @@ -211,7 +200,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_temporary_memory_properly_relocated() { let program = program!( data = vec![ @@ -239,7 +227,6 @@ mod test { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_temporary_memory_not_fully_relocated() { let program = program!( data = vec![ diff --git a/src/vm/trace/mod.rs b/src/vm/trace/mod.rs index a0e3794ffb..6f699c403a 100644 --- a/src/vm/trace/mod.rs +++ b/src/vm/trace/mod.rs @@ -4,9 +4,9 @@ use super::{ errors::{memory_errors::MemoryError, vm_errors::VirtualMachineError}, vm_memory::memory::Memory, }; -use crate::stdlib::borrow::Cow; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use num_traits::ToPrimitive; +use std::borrow::Cow; pub mod trace_entry; @@ -56,13 +56,9 @@ mod test { use crate::{utils::test_utils::*, vm::errors::memory_errors::MemoryError}; use assert_matches::assert_matches; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - /// Test that get_perm_range_check_limits() works as intended with an empty /// trace. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_empty_trace() { let trace = &[]; let memory = Memory::new(); @@ -73,7 +69,6 @@ mod test { /// Test that get_perm_range_check_limits() works as intended with a single /// trace element. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_single_element() { let trace = &[TraceEntry { pc: (0, 0).into(), @@ -91,7 +86,6 @@ mod test { /// Test that get_perm_range_check_limits() works as intended with multiple /// trace elements. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_multiple_elements() { let trace = &[ TraceEntry { diff --git a/src/vm/trace/trace_entry.rs b/src/vm/trace/trace_entry.rs index b9221a7d2d..ce27abb48e 100644 --- a/src/vm/trace/trace_entry.rs +++ b/src/vm/trace/trace_entry.rs @@ -1,5 +1,3 @@ -use crate::stdlib::prelude::*; - use crate::vm::errors::trace_errors::TraceError; use crate::{types::relocatable::Relocatable, vm::errors::memory_errors::MemoryError}; use serde::{Deserialize, Serialize}; @@ -39,7 +37,6 @@ mod tests { use super::*; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value() { let value = Relocatable { segment_index: 2, @@ -52,11 +49,7 @@ mod tests { ); } - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value_no_relocation() { let value = Relocatable { segment_index: 2, @@ -72,7 +65,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_temp_segment_address() { let value = Relocatable { segment_index: -2, diff --git a/src/vm/vm_core.rs b/src/vm/vm_core.rs index 72daf227bd..bd469ae037 100644 --- a/src/vm/vm_core.rs +++ b/src/vm/vm_core.rs @@ -1,5 +1,3 @@ -use crate::stdlib::{any::Any, borrow::Cow, collections::HashMap, prelude::*}; - use crate::{ hint_processor::hint_processor_definition::HintProcessor, serde::deserialize_program::ApTracking, @@ -23,13 +21,11 @@ use crate::{ vm_memory::memory_segments::MemorySegmentManager, }, }; - use felt::Felt; use num_traits::{ToPrimitive, Zero}; +use std::{any::Any, borrow::Cow, collections::HashMap}; -use super::runners::builtin_runner::{ - OUTPUT_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, -}; +use super::runners::builtin_runner::{RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME}; const MAX_TRACEBACK_ENTRIES: u32 = 20; @@ -948,41 +944,9 @@ impl VirtualMachine { self.segments.gen_arg(arg) } - /// Write the values hosted in the output builtin's segment. - /// Does nothing if the output builtin is not present in the program. - pub fn write_output( - &mut self, - writer: &mut impl core::fmt::Write, - ) -> Result<(), VirtualMachineError> { - let (_, builtin) = match self - .builtin_runners - .iter() - .find(|(k, _)| k == &OUTPUT_BUILTIN_NAME) - { - Some(x) => x, - _ => return Ok(()), - }; - - let segment_used_sizes = self.segments.compute_effective_sizes(); - let segment_index = builtin.base(); - #[allow(deprecated)] - for i in 0..segment_used_sizes[segment_index] { - let formatted_value = match self - .segments - .memory - .get(&Relocatable::from((segment_index as isize, i))) - { - Some(val) => match val.as_ref() { - MaybeRelocatable::Int(num) => format!("{}", num.to_bigint()), - MaybeRelocatable::RelocatableValue(rel) => format!("{}", rel), - }, - _ => "".to_string(), - }; - writeln!(writer, "{formatted_value}") - .map_err(|_| VirtualMachineError::FailedToWriteOutput)?; - } - - Ok(()) + /// Calls MemorySegmentManager::compute_effective_sizes() + pub fn compute_effective_sizes(&mut self) -> &Vec { + self.segments.compute_effective_sizes() } } @@ -1086,8 +1050,6 @@ impl VirtualMachineBuilder { #[cfg(test)] mod tests { use super::*; - use crate::stdlib::collections::HashMap; - use crate::types::program::Program; use crate::vm::runners::builtin_runner::{ BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, }; @@ -1103,6 +1065,7 @@ mod tests { bitwise_instance_def::BitwiseInstanceDef, ec_op_instance_def::EcOpInstanceDef, }, instruction::{Op1Addr, Register}, + program::Program, relocatable::Relocatable, }, utils::test_utils::*, @@ -1115,14 +1078,12 @@ mod tests { }, }; use assert_matches::assert_matches; + use std::collections::HashMap; use felt::felt_str; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::path::Path; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_successful_without_imm() { let mut vm = vm!(); vm.segments = segments![((0, 0), 5)]; @@ -1133,7 +1094,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_successful_with_imm() { let mut vm = vm!(); @@ -1150,7 +1110,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_unsuccesful() { let vm = vm!(); assert_matches!( @@ -1160,7 +1119,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_ap_plus2() { let instruction = Instruction { off0: 1, @@ -1194,7 +1152,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_dst() { let instruction = Instruction { off0: 1, @@ -1228,7 +1185,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_regular() { let instruction = Instruction { off0: 1, @@ -1262,7 +1218,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_dst_num() { let instruction = Instruction { off0: 1, @@ -1297,7 +1252,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add_with_res() { let instruction = Instruction { off0: 1, @@ -1334,7 +1288,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add_without_res() { let instruction = Instruction { off0: 1, @@ -1370,7 +1323,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add1() { let instruction = Instruction { off0: 1, @@ -1407,7 +1359,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add2() { let instruction = Instruction { off0: 1, @@ -1444,7 +1395,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_regular() { let instruction = Instruction { off0: 1, @@ -1481,7 +1431,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_regular_instruction_no_imm() { let instruction = Instruction { off0: 1, @@ -1515,7 +1464,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_regular_instruction_has_imm() { let instruction = Instruction { off0: 1, @@ -1549,7 +1497,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_with_res() { let instruction = Instruction { off0: 1, @@ -1583,7 +1530,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_without_res() { let instruction = Instruction { off0: 1, @@ -1619,7 +1565,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_with_int_res() { let instruction = Instruction { off0: 1, @@ -1654,7 +1599,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_without_res() { let instruction = Instruction { off0: 1, @@ -1687,7 +1631,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_with_non_int_res() { let instruction = Instruction { off0: 1, @@ -1719,7 +1662,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jnz_dst_is_zero() { let instruction = Instruction { off0: 1, @@ -1753,7 +1695,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jnz_dst_is_not_zero() { let instruction = Instruction { off0: 1, @@ -1787,7 +1728,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_registers_all_regular() { let instruction = Instruction { off0: 1, @@ -1826,7 +1766,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_registers_mixed_types() { let instruction = Instruction { off0: 1, @@ -1863,21 +1802,18 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_int_value() { let value = MaybeRelocatable::Int(Felt::new(1)); assert!(!VirtualMachine::is_zero(&value)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_relocatable_value() { let value = MaybeRelocatable::from((1, 2)); assert!(!VirtualMachine::is_zero(&value)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_call() { let instruction = Instruction { off0: 1, @@ -1906,7 +1842,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_add_with_optionals() { let instruction = Instruction { off0: 1, @@ -1939,7 +1874,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_add_without_optionals() { let instruction = Instruction { off0: 1, @@ -1967,7 +1901,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_mul_non_zero_op1() { let instruction = Instruction { off0: 1, @@ -2000,7 +1933,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_mul_zero_op1() { let instruction = Instruction { off0: 1, @@ -2030,7 +1962,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_op1() { let instruction = Instruction { off0: 1, @@ -2060,7 +1991,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_ret() { let instruction = Instruction { off0: 1, @@ -2091,7 +2021,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_call() { let instruction = Instruction { off0: 1, @@ -2119,7 +2048,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_add_with_optionals() { let instruction = Instruction { off0: 1, @@ -2151,7 +2079,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_add_without_optionals() { let instruction = Instruction { off0: 1, @@ -2178,7 +2105,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_mul_non_zero_op0() { let instruction = Instruction { off0: 1, @@ -2210,7 +2136,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_mul_zero_op0() { let instruction = Instruction { off0: 1, @@ -2240,7 +2165,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_op1_without_dst() { let instruction = Instruction { off0: 1, @@ -2269,7 +2193,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_op1_with_dst() { let instruction = Instruction { off0: 1, @@ -2300,7 +2223,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_op1() { let instruction = Instruction { off0: 1, @@ -2330,7 +2252,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_add() { let instruction = Instruction { off0: 1, @@ -2360,7 +2281,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_mul_int_operands() { let instruction = Instruction { off0: 1, @@ -2390,7 +2310,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_mul_relocatable_values() { let instruction = Instruction { off0: 1, @@ -2418,7 +2337,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_unconstrained() { let instruction = Instruction { off0: 1, @@ -2446,7 +2364,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_assert_eq_with_res() { let instruction = Instruction { off0: 1, @@ -2473,7 +2390,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_assert_eq_without_res() { let instruction = Instruction { off0: 1, @@ -2496,7 +2412,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_call() { let instruction = Instruction { off0: 1, @@ -2522,7 +2437,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_ret() { let instruction = Instruction { off0: 1, @@ -2545,7 +2459,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_add_ap() { let inst = Instruction { off0: 0, @@ -2606,7 +2519,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_mul_fp() { let inst = Instruction { off0: 0, @@ -2666,7 +2578,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_jnz() { let instruction = Instruction { off0: 1, @@ -2720,7 +2631,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_deduce_dst_none() { let instruction = Instruction { off0: 2, @@ -2746,7 +2656,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_res_unconstrained() { let instruction = Instruction { off0: 1, @@ -2777,7 +2686,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_instruction_failed() { let instruction = Instruction { off0: 1, @@ -2814,7 +2722,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_instruction_failed_relocatables() { let instruction = Instruction { off0: 1, @@ -2850,7 +2757,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_inconsistent_op0() { let instruction = Instruction { off0: 1, @@ -2887,7 +2793,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_inconsistent_dst() { let instruction = Instruction { off0: 1, @@ -2923,7 +2828,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /// Test for a simple program execution /// Used program code: /// func main(): @@ -2977,7 +2881,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Test for a simple program execution Used program code: @@ -3092,7 +2995,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /// Test the following program: /// ... /// [ap] = 4 @@ -3203,14 +3105,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_no_pedersen_builtin() { let vm = vm!(); assert_matches!(vm.deduce_memory_cell(Relocatable::from((0, 0))), Ok(None)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_builtin_valid() { let mut vm = vm!(); let builtin = HashBuiltinRunner::new(8, true); @@ -3225,7 +3125,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output pedersen from starkware.cairo.common.cairo_builtins import HashBuiltin @@ -3312,7 +3211,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_builtin_valid_and() { let mut vm = vm!(); let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -3326,7 +3224,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3394,7 +3291,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_builtin_valid() { let mut vm = vm!(); let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -3449,7 +3345,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Data taken from this program execution: %builtins output ec_op from starkware.cairo.common.cairo_builtins import EcOpBuiltin @@ -3514,7 +3409,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_auto_deductions_for_ec_op_builtin_valid_points_invalid_result() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); builtin.base = 3; @@ -3578,7 +3472,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3602,7 +3495,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3632,7 +3524,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output pedersen from starkware.cairo.common.cairo_builtins import HashBuiltin @@ -3666,7 +3557,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn can_get_return_values() { let mut vm = vm!(); vm.set_ap(4); @@ -3681,7 +3571,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_return_values_fails_when_ap_is_0() { let mut vm = vm!(); vm.segments = segments![((1, 0), 1), ((1, 1), 2), ((1, 2), 3), ((1, 3), 4)]; @@ -3710,7 +3599,6 @@ mod tests { */ #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_step_for_preset_memory_with_alloc_hint() { let mut vm = vm!(true); let hint_data_dictionary = HashMap::from([( @@ -3789,7 +3677,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_builtin_runners() { let mut vm = vm!(); let hash_builtin = HashBuiltinRunner::new(8, true); @@ -3806,7 +3693,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn disable_trace() { let mut vm = VirtualMachine::new(true); assert!(vm.trace.is_some()); @@ -3815,7 +3701,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -3833,7 +3718,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_non_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -3852,7 +3736,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -3869,7 +3752,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_non_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -3881,7 +3763,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_after_computing_used() { let mut vm = vm!(); vm.segments = segments![ @@ -3898,14 +3779,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_before_computing_used() { let vm = vm!(); assert_eq!(None, vm.get_segment_used_size(2)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_and_set_pc() { let mut vm = vm!(); vm.set_pc(Relocatable { @@ -3922,7 +3801,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_and_set_fp() { let mut vm = vm!(); vm.set_fp(3); @@ -3936,7 +3814,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_key_not_in_memory() { let vm = vm!(); assert_eq!( @@ -3949,14 +3826,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_error() { let vm = vm!(); assert_eq!(vm.get_maybe(&MaybeRelocatable::Int(Felt::new(0_i32))), None,); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_error() { let mut vm = vm!(); let scopes = exec_scopes_ref!(); @@ -3971,7 +3846,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_temporary_segments() { let mut vm = vm!(); let mut _base = vm.add_temporary_segment(); @@ -3993,7 +3867,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_current_instruction_invalid_encoding() { let mut vm = vm!(); vm.segments = segments![((0, 0), ("112233445566778899", 16))]; @@ -4004,7 +3877,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocation_rule_test() { let mut vm = vm!(); @@ -4031,7 +3903,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_relocatable() { let mut vm = vm!(); @@ -4044,7 +3915,6 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and no prime number just /// passes the value through. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint() { let mut vm = vm!(); @@ -4057,7 +3927,6 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and a prime number passes /// the value through after applying the modulo. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint_prime() { let mut vm = vm!(); let prime = felt_str!(felt::PRIME_STR[2..], 16); @@ -4069,7 +3938,6 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec() { let mut vm = vm!(); @@ -4090,7 +3958,6 @@ mod tests { /// Test that compute_effective_sizes() works as intended. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes() { let mut vm = vm!(); @@ -4106,7 +3973,7 @@ mod tests { ) .expect("Could not load data into memory."); - assert_eq!(vm.segments.compute_effective_sizes(), &vec![4]); + assert_eq!(vm.compute_effective_sizes(), &vec![4]); } /// Test that compute_segment_effective_sizes() works as intended. @@ -4131,7 +3998,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed() { let mut vm = vm!(); vm.run_finished = true; @@ -4169,7 +4035,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed_run_not_finished() { let mut vm = vm!(); assert_matches!( @@ -4179,7 +4044,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed_missing_accessed_addresses() { let mut vm = vm!(); assert_matches!( @@ -4189,13 +4053,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_entries_bad_usort() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/bad_programs/bad_usort.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -4214,13 +4077,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_entries_bad_dict_update() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/bad_programs/bad_dict_update.json"), + let program = Program::from_file( + Path::new("cairo_programs/bad_programs/bad_dict_update.json"), Some("main"), ) - .unwrap(); + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -4305,8 +4167,8 @@ mod tests { ); #[cfg(feature = "hooks")] { - let program = crate::types::program::Program::from_bytes( - include_bytes!("../../cairo_programs/sqrt.json"), + let program = crate::types::program::Program::from_file( + Path::new("cairo_programs/sqrt.json"), Some("main"), ) .expect("Call to `Program::from_file()` failed."); diff --git a/src/vm/vm_memory/memory.rs b/src/vm/vm_memory/memory.rs index da80a04cc2..6f6afe4892 100644 --- a/src/vm/vm_memory/memory.rs +++ b/src/vm/vm_memory/memory.rs @@ -1,10 +1,3 @@ -use crate::stdlib::{ - borrow::Cow, - collections::{HashMap, HashSet}, - fmt, - prelude::*, -}; - use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, utils::from_relocatable_to_indexes, @@ -12,7 +5,11 @@ use crate::{ }; use felt::Felt; use num_traits::ToPrimitive; - +use std::{ + borrow::Cow, + collections::{HashMap, HashSet}, + fmt::{Display, Formatter}, +}; pub struct ValidationRule( #[allow(clippy::type_complexity)] pub Box Result, MemoryError>>, @@ -358,8 +355,8 @@ impl Memory { } } -impl fmt::Display for Memory { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { +impl Display for Memory { + fn fmt(&self, f: &mut Formatter) -> std::fmt::Result { for (i, segment) in self.temp_data.iter().enumerate() { for (j, cell) in segment.iter().enumerate() { if let Some(cell) = cell { @@ -427,7 +424,7 @@ impl Default for Memory { #[cfg(test)] mod memory_tests { - use core::ops::Shl; + use std::ops::Shl; use super::*; use crate::{ @@ -448,9 +445,6 @@ mod memory_tests { use crate::utils::test_utils::memory_from_memory; use crate::utils::test_utils::memory_inner; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - pub fn memory_from( key_val_list: Vec<(MaybeRelocatable, MaybeRelocatable)>, num_segements: usize, @@ -466,7 +460,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_succesful() { let key = MaybeRelocatable::from((0, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -480,7 +473,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_valuef_from_temp_segment() { let mut memory = Memory::new(); memory.temp_data = vec![vec![ @@ -495,7 +487,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_value_in_temp_segment() { let key = MaybeRelocatable::from((-1, 3)); let val = MaybeRelocatable::from(Felt::new(8)); @@ -509,7 +500,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_succesful() { let key = MaybeRelocatable::from((-1, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -523,7 +513,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_failed() { let key = mayberelocatable!(-1, 1); let mut memory = Memory::new(); @@ -539,7 +528,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_allocated_memory() { let key = MaybeRelocatable::from((0, 0)); let memory = Memory::new(); @@ -547,7 +535,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_existant_element() { let key = MaybeRelocatable::from((0, 0)); let memory = Memory::new(); @@ -555,7 +542,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_relocatable_key() { let key = MaybeRelocatable::from(Felt::new(0)); let memory = Memory::new(); @@ -563,7 +549,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_allocated_memory() { let key = MaybeRelocatable::from((0, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -573,7 +558,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_inconsistent_memory() { let key = MaybeRelocatable::from((0, 0)); let val_a = MaybeRelocatable::from(Felt::new(5)); @@ -591,7 +575,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_address_not_relocatable() { let key = MaybeRelocatable::from(Felt::new(5)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -605,7 +588,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_contiguous_element() { let key_a = MaybeRelocatable::from((0, 0)); let key_b = MaybeRelocatable::from((0, 2)); @@ -618,7 +600,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_contiguous_element_memory_gaps_none() { let key_a = MaybeRelocatable::from((0, 0)); let key_b = MaybeRelocatable::from((0, 5)); @@ -635,7 +616,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_array_test() { let mem = memory_from( vec![( @@ -649,7 +629,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_within_bounds() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -674,7 +653,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_outside_bounds() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -699,7 +677,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_invalid_signature() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut segments = MemorySegmentManager::new(); @@ -726,7 +703,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_valid_signature() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -764,7 +740,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_relocatable_value() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -779,7 +754,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_out_of_bounds_diff_segment() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -798,7 +772,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_valid() { let memory = memory![((0, 0), 10)]; assert_eq!( @@ -811,7 +784,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_invalid_expected_integer() { let mut segments = MemorySegmentManager::new(); segments.add(); @@ -831,14 +803,12 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn default_memory() { let mem: Memory = Default::default(); assert_eq!(mem.data.len(), 0); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_temporary_succesful() { let mut memory = Memory::new(); memory.temp_data.push(Vec::new()); @@ -851,7 +821,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocation_rule() { let mut memory = Memory::new(); @@ -878,7 +847,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_bigint() { let mut memory = Memory::new(); memory @@ -896,7 +864,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable() { let mut memory = Memory::new(); memory @@ -918,7 +885,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable_temporary_segment_no_rules() { let mut memory = Memory::new(); memory @@ -937,7 +903,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable_temporary_segment_rules() { let mut memory = Memory::new(); memory @@ -966,9 +931,7 @@ mod memory_tests { Cow::Owned(MaybeRelocatable::RelocatableValue((2, 7).into())), ); } - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -985,7 +948,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_non_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -1003,7 +965,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -1019,7 +980,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_non_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -1031,7 +991,6 @@ mod memory_tests { /// Test that relocate_memory() works when there are no relocation rules. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_empty_relocation_rules() { let mut memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3)]; @@ -1040,7 +999,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_with_gap() { let mut memory = memory![ ((0, 0), 1), @@ -1075,7 +1033,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment() { let mut memory = memory![ ((0, 0), 1), @@ -1111,7 +1068,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_unallocated() { let mut memory = memory![ ((0, 0), 1), @@ -1135,7 +1091,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment() { let mut memory = memory![ ((0, 0), 1), @@ -1170,7 +1125,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment_inconsistent_memory() { let mut memory = memory![ ((0, 0), 1), @@ -1198,7 +1152,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_2_temporary_segments_one_relocated() { let mut memory = memory![ ((0, 0), 1), @@ -1236,7 +1189,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_2_temporary_segments_relocated() { let mut memory = memory![ ((0, 0), 1), @@ -1280,7 +1232,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_memory_display() { let memory = memory![ ((0, 0), 1), @@ -1300,7 +1251,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment_temporary_values_in_temporary_memory() { let mut memory = memory![ ((0, 0), 1), @@ -1334,7 +1284,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_with_rules() { let mut memory = Memory::new(); memory @@ -1355,7 +1304,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_no_rules() { let memory = Memory::new(); assert_eq!( @@ -1369,7 +1317,6 @@ mod memory_tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_real_addr() { let memory = Memory::new(); assert_eq!( diff --git a/src/vm/vm_memory/memory_segments.rs b/src/vm/vm_memory/memory_segments.rs index 6bef9c4673..1e59bbfcd6 100644 --- a/src/vm/vm_memory/memory_segments.rs +++ b/src/vm/vm_memory/memory_segments.rs @@ -1,7 +1,4 @@ -use crate::stdlib::prelude::*; -use crate::stdlib::{any::Any, collections::HashMap}; use crate::vm::runners::cairo_runner::CairoArg; - use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, vm::{ @@ -9,6 +6,7 @@ use crate::{ vm_memory::memory::Memory, }, }; +use std::{any::Any, collections::HashMap}; pub struct MemorySegmentManager { pub segment_sizes: HashMap, @@ -240,12 +238,9 @@ mod tests { use assert_matches::assert_matches; use felt::Felt; use num_traits::Num; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; + use std::vec; #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_segment_no_size() { let mut segments = MemorySegmentManager::new(); let base = segments.add(); @@ -254,7 +249,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_segment_no_size_test_two_segments() { let mut segments = MemorySegmentManager::new(); let mut _base = segments.add(); @@ -270,7 +264,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_one_temporary_segment() { let mut segments = MemorySegmentManager::new(); let base = segments.add_temporary_segment(); @@ -279,7 +272,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_two_temporary_segments() { let mut segments = MemorySegmentManager::new(); segments.add_temporary_segment(); @@ -295,7 +287,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_empty() { let data = Vec::new(); let ptr = Relocatable::from((0, 3)); @@ -305,7 +296,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_one_element() { let data = vec![MaybeRelocatable::from(Felt::new(4))]; let ptr = Relocatable::from((0, 0)); @@ -320,7 +310,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_three_elements() { let data = vec![ MaybeRelocatable::from(Felt::new(4)), @@ -355,7 +344,6 @@ mod tests { ); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory() { let mut segments = segments![((0, 0), 1), ((0, 1), 1), ((0, 2), 1)]; segments.compute_effective_sizes(); @@ -363,7 +351,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory_with_gap() { let mut segments = MemorySegmentManager::new(); segments.add(); @@ -379,7 +366,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory_with_gaps() { let mut segments = segments![((0, 3), 1), ((0, 4), 1), ((0, 7), 1), ((0, 9), 1)]; segments.compute_effective_sizes(); @@ -387,7 +373,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_three_segment_memory() { let mut segments = segments![ ((0, 0), 1), @@ -405,7 +390,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_three_segment_memory_with_gaps() { let mut segments = segments![ ((0, 2), 1), @@ -421,7 +405,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_after_computing_used() { let mut segments = segments![ ((0, 2), 1), @@ -437,14 +420,12 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_before_computing_used() { let segments = MemorySegmentManager::new(); assert_eq!(None, segments.get_segment_used_size(2)); } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_segments_one_segment() { let mut segments = MemorySegmentManager::new(); segments.segment_used_sizes = Some(vec![3]); @@ -457,7 +438,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_segments_five_segment() { let mut segments = MemorySegmentManager::new(); segments.segment_used_sizes = Some(vec![3, 3, 56, 78, 8]); @@ -470,7 +450,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_arg_with_apply_modulo() { let mut big_num = num_bigint::BigInt::from_str_radix(&felt::PRIME_STR[2..], 16) .expect("Couldn't parse prime"); @@ -497,7 +476,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_arg_relocatable() { let data = vec![ Relocatable::from((0, 1)), @@ -524,7 +502,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn segment_default() { let segment_mng_new = MemorySegmentManager::new(); let segment_mng_def: MemorySegmentManager = Default::default(); @@ -539,7 +516,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_missing_effective_sizes() { let segment_manager = MemorySegmentManager::new(); @@ -550,7 +526,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_temporary_segment() { let mut segment_manager = MemorySegmentManager::new(); @@ -562,7 +537,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_invalid_segment() { let mut segment_manager = MemorySegmentManager::new(); @@ -574,7 +548,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value() { let mut segment_manager = MemorySegmentManager::new(); @@ -586,7 +559,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_missing_segment_used_sizes() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.memory = memory![((0, 0), 0)]; @@ -600,7 +572,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_out_of_address_offset_bigger_than_size() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![2]); @@ -619,7 +590,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(Vec::new()); @@ -627,7 +597,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty2() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![4]); @@ -635,7 +604,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![10]); @@ -658,7 +626,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes2() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -683,7 +650,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size_missing_segment() { let memory_segment_manager = MemorySegmentManager::new(); @@ -691,7 +657,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size_used() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![5]); @@ -700,7 +665,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_sizes = HashMap::from([(0, 5)]); @@ -709,7 +673,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size2() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_sizes = HashMap::from([(0, 5)]); @@ -721,7 +684,6 @@ mod tests { /// Test that the call to .gen_arg() with a relocatable just passes the /// value through. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_relocatable() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -734,7 +696,6 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and no prime number just /// passes the value through. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -747,7 +708,6 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -771,7 +731,6 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec_relocatable() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -791,7 +750,6 @@ mod tests { /// Test that the call to .gen_arg() with any other argument returns a not /// implemented error. #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_invalid_type() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -802,7 +760,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_size_nor_memory_no_change() { let mut segments = MemorySegmentManager::new(); segments.finalize(None, 0, None); @@ -814,7 +771,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_memory() { let mut segments = MemorySegmentManager::new(); segments.finalize(Some(42), 0, None); @@ -823,7 +779,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_size() { let mut segments = MemorySegmentManager::new(); segments.finalize(None, 0, Some(&vec![(1_usize, 2_usize)])); @@ -835,7 +790,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_all_args() { let mut segments = MemorySegmentManager::new(); segments.finalize(Some(42), 0, Some(&vec![(1_usize, 2_usize)])); @@ -847,7 +801,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_single() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -858,7 +811,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_array() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -881,7 +833,6 @@ mod tests { } #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_composed() { let mut memory_segment_manager = MemorySegmentManager::new(); let cairo_args = CairoArg::Composed(vec![ diff --git a/src/with_alloc.rs b/src/with_alloc.rs deleted file mode 100644 index 450af26178..0000000000 --- a/src/with_alloc.rs +++ /dev/null @@ -1,15 +0,0 @@ -#[macro_use] -pub extern crate alloc; - -pub mod with_alloc { - pub use alloc::borrow; - pub use alloc::boxed; - pub use alloc::rc; - pub use alloc::string; - pub use alloc::sync; - pub use alloc::vec; - - pub mod collections { - pub use hashbrown::{HashMap, HashSet}; - } -} diff --git a/src/with_std.rs b/src/with_std.rs deleted file mode 100644 index 2b30649c4e..0000000000 --- a/src/with_std.rs +++ /dev/null @@ -1,34 +0,0 @@ -// Inspired by Substrate sp-std crate -// see https://github.com/paritytech/substrate/blob/master/primitives/std/with_std.rs - -pub mod with_std { - pub use core::time; - pub use std::alloc; - pub use std::any; - pub use std::borrow; - pub use std::boxed; - pub use std::cell; - pub use std::clone; - pub use std::cmp; - pub use std::convert; - pub use std::default; - pub use std::fmt; - pub use std::hash; - pub use std::iter; - pub use std::marker; - pub use std::mem; - pub use std::num; - pub use std::ops; - pub use std::ptr; - pub use std::rc; - pub use std::result; - pub use std::slice; - pub use std::str; - pub use std::string; - pub use std::sync; - pub use std::vec; - - pub mod collections { - pub use std::collections::{HashMap, HashSet}; - } -} diff --git a/src/without_std.rs b/src/without_std.rs deleted file mode 100644 index 1fb0b9746c..0000000000 --- a/src/without_std.rs +++ /dev/null @@ -1,24 +0,0 @@ -// Inspired by Substrate sp-std crate -// see https://github.com/paritytech/substrate/blob/master/primitives/std/without_std.rs - -pub mod without_std { - pub use core::any; - pub use core::borrow; - pub use core::cell; - pub use core::clone; - pub use core::cmp; - pub use core::convert; - pub use core::default; - pub use core::fmt; - pub use core::hash; - pub use core::iter; - pub use core::marker; - pub use core::mem; - pub use core::num; - pub use core::ops; - pub use core::ptr; - pub use core::result; - pub use core::slice; - pub use core::str; - pub use core::time; -} diff --git a/src/tests/bitwise_test.rs b/tests/bitwise_test.rs similarity index 94% rename from src/tests/bitwise_test.rs rename to tests/bitwise_test.rs index 7fc819b4fe..c2b5cf14d6 100644 --- a/src/tests/bitwise_test.rs +++ b/tests/bitwise_test.rs @@ -1,6 +1,4 @@ -use crate::stdlib::prelude::*; - -use crate::{ +use cairo_vm::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::{ @@ -9,19 +7,17 @@ use crate::{ }, }; -use assert_matches::assert_matches; - -#[cfg(target_arch = "wasm32")] -use wasm_bindgen_test::*; +#[macro_use] +extern crate assert_matches; +use std::path::Path; #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn bitwise_integration_test() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/bitwise_builtin_test.json"), + let program = Program::from_file( + Path::new("cairo_programs/bitwise_builtin_test.json"), Some("main"), ) - .unwrap(); + .expect("Failed to deserialize program"); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); diff --git a/tests/cairo_run_test.rs b/tests/cairo_run_test.rs index c1bbb9f0a7..d4b7bd88aa 100644 --- a/tests/cairo_run_test.rs +++ b/tests/cairo_run_test.rs @@ -1,11 +1,8 @@ use cairo_vm::cairo_run; use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; - -#[cfg(target_arch = "wasm32")] -use wasm_bindgen_test::*; +use std::path::Path; #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -13,7 +10,7 @@ fn cairo_run_test() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/fibonacci.json"), + Path::new("cairo_programs/fibonacci.json"), &cairo_run_config, &mut hint_executor, ) @@ -21,7 +18,6 @@ fn cairo_run_test() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_array_sum() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -29,7 +25,7 @@ fn cairo_run_array_sum() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/array_sum.json"), + Path::new("cairo_programs/array_sum.json"), &cairo_run_config, &mut hint_executor, ) @@ -37,7 +33,6 @@ fn cairo_run_array_sum() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_big_struct() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -45,7 +40,7 @@ fn cairo_run_big_struct() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/big_struct.json"), + Path::new("cairo_programs/big_struct.json"), &cairo_run_config, &mut hint_executor, ) @@ -53,7 +48,6 @@ fn cairo_run_big_struct() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_call_function_assign_param_by_name() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -61,7 +55,7 @@ fn cairo_run_call_function_assign_param_by_name() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/call_function_assign_param_by_name.json"), + Path::new("cairo_programs/call_function_assign_param_by_name.json"), &cairo_run_config, &mut hint_executor, ) @@ -69,7 +63,6 @@ fn cairo_run_call_function_assign_param_by_name() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -77,7 +70,7 @@ fn cairo_run_function_return() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/function_return.json"), + Path::new("cairo_programs/function_return.json"), &cairo_run_config, &mut hint_executor, ) @@ -85,7 +78,6 @@ fn cairo_run_function_return() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return_if_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -93,7 +85,7 @@ fn cairo_run_function_return_if_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/function_return_if_print.json"), + Path::new("cairo_programs/function_return_if_print.json"), &cairo_run_config, &mut hint_executor, ) @@ -101,7 +93,6 @@ fn cairo_run_function_return_if_print() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return_to_variable() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -109,7 +100,7 @@ fn cairo_run_function_return_to_variable() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/function_return_to_variable.json"), + Path::new("cairo_programs/function_return_to_variable.json"), &cairo_run_config, &mut hint_executor, ) @@ -117,7 +108,6 @@ fn cairo_run_function_return_to_variable() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_and_prime() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -125,7 +115,7 @@ fn cairo_run_if_and_prime() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/if_and_prime.json"), + Path::new("cairo_programs/if_and_prime.json"), &cairo_run_config, &mut hint_executor, ) @@ -133,7 +123,6 @@ fn cairo_run_if_and_prime() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_in_function() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -141,7 +130,7 @@ fn cairo_run_if_in_function() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/if_in_function.json"), + Path::new("cairo_programs/if_in_function.json"), &cairo_run_config, &mut hint_executor, ) @@ -149,7 +138,6 @@ fn cairo_run_if_in_function() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_list() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -157,7 +145,7 @@ fn cairo_run_if_list() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/if_list.json"), + Path::new("cairo_programs/if_list.json"), &cairo_run_config, &mut hint_executor, ) @@ -165,7 +153,6 @@ fn cairo_run_if_list() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_jmp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -173,7 +160,7 @@ fn cairo_run_jmp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/jmp.json"), + Path::new("cairo_programs/jmp.json"), &cairo_run_config, &mut hint_executor, ) @@ -181,7 +168,6 @@ fn cairo_run_jmp() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_jmp_if_condition() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -189,7 +175,7 @@ fn cairo_run_jmp_if_condition() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/jmp_if_condition.json"), + Path::new("cairo_programs/jmp_if_condition.json"), &cairo_run_config, &mut hint_executor, ) @@ -197,7 +183,6 @@ fn cairo_run_jmp_if_condition() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_pointers() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -205,7 +190,7 @@ fn cairo_run_pointers() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/pointers.json"), + Path::new("cairo_programs/pointers.json"), &cairo_run_config, &mut hint_executor, ) @@ -213,7 +198,6 @@ fn cairo_run_pointers() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -221,7 +205,7 @@ fn cairo_run_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/print.json"), + Path::new("cairo_programs/print.json"), &cairo_run_config, &mut hint_executor, ) @@ -229,7 +213,6 @@ fn cairo_run_print() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_return() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -237,7 +220,7 @@ fn cairo_run_return() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/return.json"), + Path::new("cairo_programs/return.json"), &cairo_run_config, &mut hint_executor, ) @@ -245,7 +228,6 @@ fn cairo_run_return() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_reversed_register_instructions() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -253,7 +235,7 @@ fn cairo_run_reversed_register_instructions() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/reversed_register_instructions.json"), + Path::new("cairo_programs/reversed_register_instructions.json"), &cairo_run_config, &mut hint_executor, ) @@ -261,7 +243,6 @@ fn cairo_run_reversed_register_instructions() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_simple_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -269,7 +250,7 @@ fn cairo_run_simple_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/simple_print.json"), + Path::new("cairo_programs/simple_print.json"), &cairo_run_config, &mut hint_executor, ) @@ -277,7 +258,6 @@ fn cairo_run_simple_print() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_addition_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -285,7 +265,7 @@ fn cairo_run_test_addition_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/test_addition_if.json"), + Path::new("cairo_programs/test_addition_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -293,7 +273,6 @@ fn cairo_run_test_addition_if() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_reverse_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -301,7 +280,7 @@ fn cairo_run_test_reverse_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/test_reverse_if.json"), + Path::new("cairo_programs/test_reverse_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -309,7 +288,6 @@ fn cairo_run_test_reverse_if() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_subtraction_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -317,7 +295,7 @@ fn cairo_run_test_subtraction_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/test_subtraction_if.json"), + Path::new("cairo_programs/test_subtraction_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -325,7 +303,6 @@ fn cairo_run_test_subtraction_if() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_use_imported_module() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -333,7 +310,7 @@ fn cairo_run_use_imported_module() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/use_imported_module.json"), + Path::new("cairo_programs/use_imported_module.json"), &cairo_run_config, &mut hint_executor, ) @@ -341,7 +318,6 @@ fn cairo_run_use_imported_module() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_bitwise_output() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -349,7 +325,7 @@ fn cairo_run_bitwise_output() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/bitwise_output.json"), + Path::new("cairo_programs/bitwise_output.json"), &cairo_run_config, &mut hint_executor, ) @@ -357,7 +333,6 @@ fn cairo_run_bitwise_output() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_bitwise_recursion() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -365,7 +340,7 @@ fn cairo_run_bitwise_recursion() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/bitwise_recursion.json"), + Path::new("cairo_programs/bitwise_recursion.json"), &cairo_run_config, &mut hint_executor, ) @@ -373,7 +348,6 @@ fn cairo_run_bitwise_recursion() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -381,7 +355,7 @@ fn cairo_run_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/integration.json"), + Path::new("cairo_programs/integration.json"), &cairo_run_config, &mut hint_executor, ) @@ -389,7 +363,6 @@ fn cairo_run_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_integration_with_alloc_locals() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -397,7 +370,7 @@ fn cairo_run_integration_with_alloc_locals() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/integration_with_alloc_locals.json"), + Path::new("cairo_programs/integration_with_alloc_locals.json"), &cairo_run_config, &mut hint_executor, ) @@ -405,7 +378,6 @@ fn cairo_run_integration_with_alloc_locals() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_arrays() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -413,7 +385,7 @@ fn cairo_run_compare_arrays() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/compare_arrays.json"), + Path::new("cairo_programs/compare_arrays.json"), &cairo_run_config, &mut hint_executor, ) @@ -421,7 +393,6 @@ fn cairo_run_compare_arrays() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_greater_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -429,7 +400,7 @@ fn cairo_run_compare_greater_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/compare_greater_array.json"), + Path::new("cairo_programs/compare_greater_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -437,7 +408,6 @@ fn cairo_run_compare_greater_array() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_lesser_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -445,7 +415,7 @@ fn cairo_run_compare_lesser_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/compare_lesser_array.json"), + Path::new("cairo_programs/compare_lesser_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -453,7 +423,6 @@ fn cairo_run_compare_lesser_array() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_le_felt_hint() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -461,7 +430,7 @@ fn cairo_run_assert_le_felt_hint() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/assert_le_felt_hint.json"), + Path::new("cairo_programs/assert_le_felt_hint.json"), &cairo_run_config, &mut hint_executor, ) @@ -469,7 +438,6 @@ fn cairo_run_assert_le_felt_hint() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_250_bit_element_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -477,7 +445,7 @@ fn cairo_run_assert_250_bit_element_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/assert_250_bit_element_array.json"), + Path::new("cairo_programs/assert_250_bit_element_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -485,7 +453,6 @@ fn cairo_run_assert_250_bit_element_array() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_abs_value() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -493,7 +460,7 @@ fn cairo_abs_value() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/abs_value_array.json"), + Path::new("cairo_programs/abs_value_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -501,7 +468,6 @@ fn cairo_abs_value() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_different_arrays() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -509,7 +475,7 @@ fn cairo_run_compare_different_arrays() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/compare_different_arrays.json"), + Path::new("cairo_programs/compare_different_arrays.json"), &cairo_run_config, &mut hint_executor, ) @@ -517,7 +483,6 @@ fn cairo_run_compare_different_arrays() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_nn() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -525,7 +490,7 @@ fn cairo_run_assert_nn() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/assert_nn.json"), + Path::new("cairo_programs/assert_nn.json"), &cairo_run_config, &mut hint_executor, ) @@ -533,7 +498,6 @@ fn cairo_run_assert_nn() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_sqrt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -541,7 +505,7 @@ fn cairo_run_sqrt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/sqrt.json"), + Path::new("cairo_programs/sqrt.json"), &cairo_run_config, &mut hint_executor, ) @@ -549,7 +513,6 @@ fn cairo_run_sqrt() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_not_zero() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -557,7 +520,7 @@ fn cairo_run_assert_not_zero() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/assert_not_zero.json"), + Path::new("cairo_programs/assert_not_zero.json"), &cairo_run_config, &mut hint_executor, ) @@ -565,7 +528,6 @@ fn cairo_run_assert_not_zero() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_int() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -573,7 +535,7 @@ fn cairo_run_split_int() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/split_int.json"), + Path::new("cairo_programs/split_int.json"), &cairo_run_config, &mut hint_executor, ) @@ -581,7 +543,6 @@ fn cairo_run_split_int() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_int_big() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -589,7 +550,7 @@ fn cairo_run_split_int_big() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/split_int_big.json"), + Path::new("cairo_programs/split_int_big.json"), &cairo_run_config, &mut hint_executor, ) @@ -597,7 +558,6 @@ fn cairo_run_split_int_big() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_felt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -605,7 +565,7 @@ fn cairo_run_split_felt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/split_felt.json"), + Path::new("cairo_programs/split_felt.json"), &cairo_run_config, &mut hint_executor, ) @@ -613,7 +573,6 @@ fn cairo_run_split_felt() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_math_cmp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -621,7 +580,7 @@ fn cairo_run_math_cmp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/math_cmp.json"), + Path::new("cairo_programs/math_cmp.json"), &cairo_run_config, &mut hint_executor, ) @@ -629,7 +588,6 @@ fn cairo_run_math_cmp() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsigned_div_rem() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -637,7 +595,7 @@ fn cairo_run_unsigned_div_rem() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/unsigned_div_rem.json"), + Path::new("cairo_programs/unsigned_div_rem.json"), &cairo_run_config, &mut hint_executor, ) @@ -645,7 +603,6 @@ fn cairo_run_unsigned_div_rem() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_signed_div_rem() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -653,7 +610,7 @@ fn cairo_run_signed_div_rem() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/signed_div_rem.json"), + Path::new("cairo_programs/signed_div_rem.json"), &cairo_run_config, &mut hint_executor, ) @@ -661,7 +618,6 @@ fn cairo_run_signed_div_rem() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_lt_felt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -669,7 +625,7 @@ fn cairo_run_assert_lt_felt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/assert_lt_felt.json"), + Path::new("cairo_programs/assert_lt_felt.json"), &cairo_run_config, &mut hint_executor, ) @@ -677,7 +633,6 @@ fn cairo_run_assert_lt_felt() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memcpy() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -685,7 +640,7 @@ fn cairo_run_memcpy() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/memcpy_test.json"), + Path::new("cairo_programs/memcpy_test.json"), &cairo_run_config, &mut hint_executor, ) @@ -693,7 +648,6 @@ fn cairo_run_memcpy() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memset() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -701,7 +655,7 @@ fn cairo_run_memset() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/memset.json"), + Path::new("cairo_programs/memset.json"), &cairo_run_config, &mut hint_executor, ) @@ -709,7 +663,6 @@ fn cairo_run_memset() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_pow() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -717,7 +670,7 @@ fn cairo_run_pow() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/pow.json"), + Path::new("cairo_programs/pow.json"), &cairo_run_config, &mut hint_executor, ) @@ -725,7 +678,6 @@ fn cairo_run_pow() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -733,7 +685,7 @@ fn cairo_run_dict() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/dict.json"), + Path::new("cairo_programs/dict.json"), &cairo_run_config, &mut hint_executor, ) @@ -741,7 +693,6 @@ fn cairo_run_dict() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_update() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -749,7 +700,7 @@ fn cairo_run_dict_update() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/dict_update.json"), + Path::new("cairo_programs/dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -757,7 +708,6 @@ fn cairo_run_dict_update() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_uint256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -765,7 +715,7 @@ fn cairo_run_uint256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/uint256.json"), + Path::new("cairo_programs/uint256.json"), &cairo_run_config, &mut hint_executor, ) @@ -773,7 +723,6 @@ fn cairo_run_uint256() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_find_element() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -781,7 +730,7 @@ fn cairo_run_find_element() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/find_element.json"), + Path::new("cairo_programs/find_element.json"), &cairo_run_config, &mut hint_executor, ) @@ -789,7 +738,6 @@ fn cairo_run_find_element() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_search_sorted_lower() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -797,7 +745,7 @@ fn cairo_run_search_sorted_lower() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/search_sorted_lower.json"), + Path::new("cairo_programs/search_sorted_lower.json"), &cairo_run_config, &mut hint_executor, ) @@ -805,7 +753,6 @@ fn cairo_run_search_sorted_lower() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_usort() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -813,7 +760,7 @@ fn cairo_run_usort() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/usort.json"), + Path::new("cairo_programs/usort.json"), &cairo_run_config, &mut hint_executor, ) @@ -821,7 +768,6 @@ fn cairo_run_usort() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_usort_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -829,7 +775,7 @@ fn cairo_run_usort_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - include_bytes!("../cairo_programs/bad_programs/bad_usort.json"), + Path::new("cairo_programs/bad_programs/bad_usort.json"), &cairo_run_config, &mut hint_executor, ); @@ -842,7 +788,6 @@ fn cairo_run_usort_bad() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_write_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -850,7 +795,7 @@ fn cairo_run_dict_write_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; assert!(cairo_run::cairo_run( - include_bytes!("../cairo_programs/bad_programs/bad_dict_new.json"), + Path::new("cairo_programs/bad_programs/bad_dict_new.json"), &cairo_run_config, &mut hint_executor, ) @@ -861,7 +806,7 @@ fn cairo_run_dict_write_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - include_bytes!("../cairo_programs/bad_programs/bad_dict_new.json"), + Path::new("cairo_programs/bad_programs/bad_dict_new.json"), &cairo_run_config, &mut hint_executor, ) @@ -873,7 +818,6 @@ fn cairo_run_dict_write_bad() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_update_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -881,7 +825,7 @@ fn cairo_run_dict_update_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; assert!(cairo_run::cairo_run( - include_bytes!("../cairo_programs/bad_programs/bad_dict_update.json"), + Path::new("cairo_programs/bad_programs/bad_dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -892,7 +836,7 @@ fn cairo_run_dict_update_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - include_bytes!("../cairo_programs/bad_programs/bad_dict_update.json"), + Path::new("cairo_programs/bad_programs/bad_dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -903,7 +847,6 @@ fn cairo_run_dict_update_bad() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_squash_dict() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -911,7 +854,7 @@ fn cairo_run_squash_dict() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/squash_dict.json"), + Path::new("cairo_programs/squash_dict.json"), &cairo_run_config, &mut hint_executor, ) @@ -919,7 +862,6 @@ fn cairo_run_squash_dict() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_squash() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -927,7 +869,7 @@ fn cairo_run_dict_squash() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/dict_squash.json"), + Path::new("cairo_programs/dict_squash.json"), &cairo_run_config, &mut hint_executor, ) @@ -935,7 +877,6 @@ fn cairo_run_dict_squash() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_set_add() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -943,7 +884,7 @@ fn cairo_run_set_add() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/set_add.json"), + Path::new("cairo_programs/set_add.json"), &cairo_run_config, &mut hint_executor, ) @@ -951,7 +892,6 @@ fn cairo_run_set_add() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -959,7 +899,7 @@ fn cairo_run_secp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/secp.json"), + Path::new("cairo_programs/secp.json"), &cairo_run_config, &mut hint_executor, ) @@ -967,7 +907,6 @@ fn cairo_run_secp() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_signature() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -975,7 +914,7 @@ fn cairo_run_signature() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/signature.json"), + Path::new("cairo_programs/signature.json"), &cairo_run_config, &mut hint_executor, ) @@ -983,7 +922,6 @@ fn cairo_run_signature() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp_ec() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -991,7 +929,7 @@ fn cairo_run_secp_ec() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/secp_ec.json"), + Path::new("cairo_programs/secp_ec.json"), &cairo_run_config, &mut hint_executor, ) @@ -999,7 +937,6 @@ fn cairo_run_secp_ec() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_hello_world_hash() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1007,7 +944,7 @@ fn cairo_run_blake2s_hello_world_hash() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/blake2s_hello_world_hash.json"), + Path::new("cairo_programs/blake2s_hello_world_hash.json"), &cairo_run_config, &mut hint_executor, ) @@ -1015,7 +952,6 @@ fn cairo_run_blake2s_hello_world_hash() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_finalize_blake2s() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1023,14 +959,13 @@ fn cairo_run_finalize_blake2s() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/finalize_blake2s.json"), + Path::new("cairo_programs/finalize_blake2s.json"), &cairo_run_config, &mut hint_executor, ) .expect("Couldn't run program"); } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsafe_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1038,7 +973,7 @@ fn cairo_run_unsafe_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/unsafe_keccak.json"), + Path::new("cairo_programs/unsafe_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -1046,7 +981,6 @@ fn cairo_run_unsafe_keccak() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_felts() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1054,7 +988,7 @@ fn cairo_run_blake2s_felts() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/blake2s_felts.json"), + Path::new("cairo_programs/blake2s_felts.json"), &cairo_run_config, &mut hint_executor, ) @@ -1062,7 +996,6 @@ fn cairo_run_blake2s_felts() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsafe_keccak_finalize() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1070,7 +1003,7 @@ fn cairo_run_unsafe_keccak_finalize() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/unsafe_keccak_finalize.json"), + Path::new("cairo_programs/unsafe_keccak_finalize.json"), &cairo_run_config, &mut hint_executor, ) @@ -1078,7 +1011,6 @@ fn cairo_run_unsafe_keccak_finalize() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_add_uint256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1086,7 +1018,7 @@ fn cairo_run_keccak_add_uint256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/keccak_add_uint256.json"), + Path::new("cairo_programs/keccak_add_uint256.json"), &cairo_run_config, &mut hint_executor, ) @@ -1094,7 +1026,6 @@ fn cairo_run_keccak_add_uint256() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_private_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1102,7 +1033,7 @@ fn cairo_run_private_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/_keccak.json"), + Path::new("cairo_programs/_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -1110,7 +1041,6 @@ fn cairo_run_private_keccak() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_copy_inputs() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1118,7 +1048,7 @@ fn cairo_run_keccak_copy_inputs() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/keccak_copy_inputs.json"), + Path::new("cairo_programs/keccak_copy_inputs.json"), &cairo_run_config, &mut hint_executor, ) @@ -1126,7 +1056,6 @@ fn cairo_run_keccak_copy_inputs() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_finalize_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1134,7 +1063,7 @@ fn cairo_run_finalize_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/cairo_finalize_keccak.json"), + Path::new("cairo_programs/cairo_finalize_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -1142,7 +1071,6 @@ fn cairo_run_finalize_keccak() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_operations_with_data() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1150,7 +1078,7 @@ fn cairo_run_operations_with_data() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/operations_with_data_structures.json"), + Path::new("cairo_programs/operations_with_data_structures.json"), &cairo_run_config, &mut hint_executor, ) @@ -1158,7 +1086,6 @@ fn cairo_run_operations_with_data() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_sha256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1166,7 +1093,7 @@ fn cairo_run_sha256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/sha256.json"), + Path::new("cairo_programs/sha256.json"), &cairo_run_config, &mut hint_executor, ) @@ -1174,7 +1101,6 @@ fn cairo_run_sha256() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_math_cmp_and_pow_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1182,7 +1108,7 @@ fn cairo_run_math_cmp_and_pow_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/math_cmp_and_pow_integration_tests.json"), + Path::new("cairo_programs/math_cmp_and_pow_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1190,7 +1116,6 @@ fn cairo_run_math_cmp_and_pow_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_uint256_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1198,7 +1123,7 @@ fn cairo_run_uint256_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/uint256_integration_tests.json"), + Path::new("cairo_programs/uint256_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1206,7 +1131,6 @@ fn cairo_run_uint256_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_set_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1214,7 +1138,7 @@ fn cairo_run_set_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/set_integration_tests.json"), + Path::new("cairo_programs/set_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1222,7 +1146,6 @@ fn cairo_run_set_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memory_module_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1230,7 +1153,7 @@ fn cairo_run_memory_module_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/memory_integration_tests.json"), + Path::new("cairo_programs/memory_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1238,7 +1161,6 @@ fn cairo_run_memory_module_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1246,7 +1168,7 @@ fn cairo_run_dict_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/dict_integration_tests.json"), + Path::new("cairo_programs/dict_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1254,7 +1176,6 @@ fn cairo_run_dict_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1262,7 +1183,7 @@ fn cairo_run_secp_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/secp_integration_tests.json"), + Path::new("cairo_programs/secp_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1270,7 +1191,6 @@ fn cairo_run_secp_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1278,7 +1198,7 @@ fn cairo_run_keccak_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/keccak_integration_tests.json"), + Path::new("cairo_programs/keccak_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1286,7 +1206,6 @@ fn cairo_run_keccak_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1294,7 +1213,7 @@ fn cairo_run_blake2s_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/blake2s_integration_tests.json"), + Path::new("cairo_programs/blake2s_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1302,7 +1221,6 @@ fn cairo_run_blake2s_integration() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_relocate_segments() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1310,7 +1228,7 @@ fn cairo_run_relocate_segments() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/relocate_segments.json"), + Path::new("cairo_programs/relocate_segments.json"), &cairo_run_config, &mut hint_executor, ) @@ -1318,7 +1236,6 @@ fn cairo_run_relocate_segments() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1326,7 +1243,7 @@ fn cairo_run_error_msg_attr() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - include_bytes!("../cairo_programs/bad_programs/error_msg_attr.json"), + Path::new("cairo_programs/bad_programs/error_msg_attr.json"), &cairo_run_config, &mut hint_executor, ) @@ -1337,7 +1254,6 @@ fn cairo_run_error_msg_attr() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr_ap_based_reference() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1345,22 +1261,17 @@ fn cairo_run_error_msg_attr_ap_based_reference() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - include_bytes!("../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), &cairo_run_config, &mut hint_executor, ) .err() .unwrap(); - #[cfg(feature = "std")] assert_eq!(err.to_string(), String::from("Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n assert x = 2;\n ^***********^\n")); - - #[cfg(not(feature = "std"))] - assert_eq!(err.to_string(), String::from("Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n")); } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr_complex_reference() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1368,7 +1279,7 @@ fn cairo_run_error_msg_attr_complex_reference() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - include_bytes!("../cairo_programs/bad_programs/error_msg_attr_struct.json"), + Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), &cairo_run_config, &mut hint_executor, ) @@ -1378,7 +1289,6 @@ fn cairo_run_error_msg_attr_complex_reference() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_store_cast_pointer() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1386,7 +1296,7 @@ fn cairo_run_dict_store_cast_pointer() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/dict_store_cast_ptr.json"), + Path::new("cairo_programs/dict_store_cast_ptr.json"), &cairo_run_config, &mut hint_executor, ) @@ -1394,7 +1304,6 @@ fn cairo_run_dict_store_cast_pointer() { } #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_verify_signature_hint() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1402,7 +1311,7 @@ fn cairo_run_verify_signature_hint() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("../cairo_programs/common_signature.json"), + Path::new("cairo_programs/common_signature.json"), &cairo_run_config, &mut hint_executor, ) diff --git a/src/tests/compare_vm_state.sh b/tests/compare_vm_state.sh similarity index 100% rename from src/tests/compare_vm_state.sh rename to tests/compare_vm_state.sh diff --git a/src/tests/memory_comparator.py b/tests/memory_comparator.py similarity index 100% rename from src/tests/memory_comparator.py rename to tests/memory_comparator.py diff --git a/src/tests/pedersen_test.rs b/tests/pedersen_test.rs similarity index 87% rename from src/tests/pedersen_test.rs rename to tests/pedersen_test.rs index bc21549338..0392243d69 100644 --- a/src/tests/pedersen_test.rs +++ b/tests/pedersen_test.rs @@ -1,25 +1,17 @@ -use crate::stdlib::prelude::*; - -use crate::{ +use std::path::Path; +#[macro_use] +extern crate assert_matches; +use cairo_vm::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::trace::trace_entry::RelocatedTraceEntry, vm::{runners::cairo_runner::CairoRunner, vm_core::VirtualMachine}, }; -use assert_matches::assert_matches; - -#[cfg(target_arch = "wasm32")] -use wasm_bindgen_test::*; - #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn pedersen_integration_test() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/pedersen_test.json"), - Some("main"), - ) - .unwrap(); + let program = Program::from_file(Path::new("cairo_programs/pedersen_test.json"), Some("main")) + .expect("Failed to deserialize program"); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); diff --git a/src/tests/skip_instruction_test.rs b/tests/skip_instruction_test.rs similarity index 61% rename from src/tests/skip_instruction_test.rs rename to tests/skip_instruction_test.rs index d781c8faac..c8675e58a5 100644 --- a/src/tests/skip_instruction_test.rs +++ b/tests/skip_instruction_test.rs @@ -1,24 +1,23 @@ -use crate::{ +#[cfg(feature = "skip_next_instruction_hint")] +use cairo_vm::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::{runners::cairo_runner::CairoRunner, vm_core::VirtualMachine}, }; +#[macro_use] +extern crate assert_matches; -use assert_matches::assert_matches; - -#[cfg(target_arch = "wasm32")] -use wasm_bindgen_test::*; +#[cfg(feature = "skip_next_instruction_hint")] +use std::path::Path; +#[cfg(feature = "skip_next_instruction_hint")] #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn skip_next_instruction_test() { - let program = Program::from_bytes( - include_bytes!( - "../../cairo_programs/noretrocompat/test_skip_next_instruction.noretrocompat.json" - ), + let program = Program::from_file( + Path::new("cairo_programs/noretrocompat/test_skip_next_instruction.noretrocompat.json"), Some("main"), ) - .unwrap(); + .expect("Failed to deserialize program"); let mut hint_processor = BuiltinHintProcessor::new_empty(); diff --git a/src/tests/struct_test.rs b/tests/struct_test.rs similarity index 63% rename from src/tests/struct_test.rs rename to tests/struct_test.rs index 72b7f65d86..cd443c051f 100644 --- a/src/tests/struct_test.rs +++ b/tests/struct_test.rs @@ -1,23 +1,21 @@ -use crate::{ +use cairo_vm::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, - types::program::Program, vm::vm_core::VirtualMachine, + vm::vm_core::VirtualMachine, }; +use std::path::Path; -use crate::vm::{runners::cairo_runner::CairoRunner, trace::trace_entry::RelocatedTraceEntry}; - -use assert_matches::assert_matches; +use cairo_vm::{ + types::program::Program, + vm::{runners::cairo_runner::CairoRunner, trace::trace_entry::RelocatedTraceEntry}, +}; -#[cfg(target_arch = "wasm32")] -use wasm_bindgen_test::*; +#[macro_use] +extern crate assert_matches; #[test] -#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn struct_integration_test() { - let program = Program::from_bytes( - include_bytes!("../../cairo_programs/struct.json"), - Some("main"), - ) - .unwrap(); + let program = Program::from_file(Path::new("cairo_programs/struct.json"), Some("main")) + .expect("Failed to deserialize program"); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); From ae6c5628d2dbcf4b156c6c474fabff507c75efc2 Mon Sep 17 00:00:00 2001 From: Mario Rugiero Date: Fri, 10 Mar 2023 13:59:19 -0300 Subject: [PATCH 04/15] Extend IAI benchmark to include all serializations and proof mode (#892) * Extend IAI benchmark to include all serializations and proof mode * Use expect * See if the issue is /dev/null * Set RUST_BACKTRACE * Found the error, proof mode fails the bench * Corrected comment * Revert "Set RUST_BACKTRACE" This reverts commit 9e31b801e34c3b7a4432c63ab03cce01328d08af. --- bench/iai_benchmark.rs | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/bench/iai_benchmark.rs b/bench/iai_benchmark.rs index 9763e99983..f956bf7c87 100644 --- a/bench/iai_benchmark.rs +++ b/bench/iai_benchmark.rs @@ -1,26 +1,46 @@ use std::path::Path; use cairo_vm::{ - cairo_run::cairo_run, + cairo_run::*, hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, - vm::errors::cairo_run_errors::CairoRunError, vm::runners::cairo_runner::CairoRunner, }; use iai::{black_box, main}; macro_rules! iai_bench_expand_prog { ($val: ident) => { - fn $val() -> Result { + fn $val() { let cairo_run_config = cairo_vm::cairo_run::CairoRunConfig { + trace_enabled: true, layout: "all", + print_output: true, + //FIXME: we need to distinguish the proof compiled programs + //proof_mode: true, + secure_run: Some(true), ..cairo_vm::cairo_run::CairoRunConfig::default() }; let mut hint_executor = BuiltinHintProcessor::new_empty(); - let path = Path::new(concat!( + let program_path = Path::new(concat!( "cairo_programs/benchmarks/", stringify!($val), ".json" )); - cairo_run(black_box(path), &cairo_run_config, &mut hint_executor) + let trace_path = Path::new("/dev/null"); + let memory_path = Path::new("/dev/null"); + + let runner = cairo_run( + black_box(program_path), + &cairo_run_config, + &mut hint_executor, + ) + .expect("cairo_run failed"); + + let relocated_trace = runner.relocated_trace.as_ref().expect("relocation failed"); + + write_binary_trace(black_box(relocated_trace), black_box(&trace_path)) + .expect("writing execution trace failed"); + + write_binary_memory(black_box(&runner.relocated_memory), black_box(&memory_path)) + .expect("writing relocated memory failed"); } }; } From 2ec04a4ac0f76cc98451e52372e5792d02267d20 Mon Sep 17 00:00:00 2001 From: Alon Haramati <91828241+alonh5@users.noreply.github.com> Date: Mon, 13 Mar 2023 16:15:42 +0200 Subject: [PATCH 05/15] Fix error typos. (#894) --- src/types/errors/math_errors.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/types/errors/math_errors.rs b/src/types/errors/math_errors.rs index bb7accb49a..dbe06dde19 100644 --- a/src/types/errors/math_errors.rs +++ b/src/types/errors/math_errors.rs @@ -32,15 +32,15 @@ pub enum MathError { RelocatableAddFeltOffsetExceeded(Relocatable, Felt), #[error("Operation failed: {0} + {1}, maximum offset value exceeded")] RelocatableAddUsizeOffsetExceeded(Relocatable, usize), - #[error("Operation failed: {0} + {1}, cant add two relocatable values")] + #[error("Operation failed: {0} + {1}, can't add two relocatable values")] RelocatableAdd(Relocatable, Relocatable), - #[error("Operation failed: {0} - {1}, cant substract two relocatable values with different segment indexes")] + #[error("Operation failed: {0} - {1}, can't subtract two relocatable values with different segment indexes")] RelocatableSubDiffIndex(Relocatable, Relocatable), #[error( "Operation failed: {0}.divmod({1}, divmod can only be performed between two integer values" )] DivModWrongType(MaybeRelocatable, MaybeRelocatable), - #[error("Operation failed {0} - {1}, cant substract a relocatable value from an integer")] + #[error("Operation failed {0} - {1}, can't subtract a relocatable value from an integer")] SubRelocatableFromInt(Felt, Relocatable), // Type conversions #[error("Conversion to i32 failed for Felt {0}")] From e32e43539525399a03853f02e719d4d215d81405 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timoth=C3=A9e=20Delabrouille?= <34384633+tdelabro@users.noreply.github.com> Date: Tue, 14 Mar 2023 20:32:50 +0100 Subject: [PATCH 06/15] feat: impl Deserialize on Program by changing builtins field type to enum (#896) --- src/serde/deserialize_program.rs | 12 +- src/types/program.rs | 20 +- src/utils.rs | 14 +- src/vm/runners/builtin_runner/bitwise.rs | 6 +- src/vm/runners/builtin_runner/ec_op.rs | 6 +- src/vm/runners/builtin_runner/hash.rs | 5 +- src/vm/runners/builtin_runner/mod.rs | 9 +- src/vm/runners/builtin_runner/range_check.rs | 5 +- src/vm/runners/cairo_runner.rs | 220 ++++++++++--------- src/vm/security.rs | 6 +- 10 files changed, 154 insertions(+), 149 deletions(-) diff --git a/src/serde/deserialize_program.rs b/src/serde/deserialize_program.rs index bfe1f6deb6..7a540fc6b1 100644 --- a/src/serde/deserialize_program.rs +++ b/src/serde/deserialize_program.rs @@ -16,7 +16,7 @@ use serde_json::Number; use std::{collections::HashMap, fmt, io::Read}; // This enum is used to deserialize program builtins into &str and catch non-valid names -#[derive(Deserialize, Debug, PartialEq)] +#[derive(Serialize, Deserialize, Debug, PartialEq, Copy, Clone, Eq)] #[allow(non_camel_case_types)] pub enum BuiltinName { output, @@ -365,11 +365,7 @@ pub fn deserialize_program( }; Ok(Program { - builtins: program_json - .builtins - .iter() - .map(BuiltinName::name) - .collect(), + builtins: program_json.builtins, prime: PRIME_STR.to_string(), data: program_json.data, constants: { @@ -753,7 +749,7 @@ mod tests { let program: Program = deserialize_program(reader, Some("main")).expect("Failed to deserialize program"); - let builtins: Vec = Vec::new(); + let builtins: Vec = Vec::new(); let data: Vec = vec![ MaybeRelocatable::Int(Felt::new(5189976364521848832_i64)), MaybeRelocatable::Int(Felt::new(1000)), @@ -816,7 +812,7 @@ mod tests { let program: Program = deserialize_program(reader, None).expect("Failed to deserialize program"); - let builtins: Vec = Vec::new(); + let builtins: Vec = Vec::new(); let data: Vec = vec![ MaybeRelocatable::Int(Felt::new(5189976364521848832_i64)), MaybeRelocatable::Int(Felt::new(1000)), diff --git a/src/types/program.rs b/src/types/program.rs index 36cbc9ad8a..04df56fcbc 100644 --- a/src/types/program.rs +++ b/src/types/program.rs @@ -1,21 +1,21 @@ use crate::{ serde::deserialize_program::{ - deserialize_program, Attribute, HintParams, Identifier, InstructionLocation, + deserialize_program, Attribute, BuiltinName, HintParams, Identifier, InstructionLocation, ReferenceManager, }, types::{errors::program_errors::ProgramError, relocatable::MaybeRelocatable}, }; use felt::{Felt, PRIME_STR}; -use serde::Serialize; +use serde::{Deserialize, Serialize}; use std::{ fs::File, io::{BufReader, Read}, {collections::HashMap, path::Path}, }; -#[derive(Clone, Debug, PartialEq, Eq, Serialize)] +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct Program { - pub builtins: Vec<&'static str>, + pub builtins: Vec, pub prime: String, pub data: Vec, pub constants: HashMap, @@ -33,7 +33,7 @@ pub struct Program { impl Program { #[allow(clippy::too_many_arguments)] pub fn new( - builtins: Vec<&'static str>, + builtins: Vec, prime: String, data: Vec, main: Option, @@ -121,7 +121,7 @@ mod tests { references: Vec::new(), }; - let builtins: Vec<&'static str> = Vec::new(); + let builtins: Vec = Vec::new(); let data: Vec = vec![ mayberelocatable!(5189976364521848832), mayberelocatable!(1000), @@ -156,7 +156,7 @@ mod tests { references: Vec::new(), }; - let builtins: Vec<&'static str> = Vec::new(); + let builtins: Vec = Vec::new(); let data: Vec = vec![ mayberelocatable!(5189976364521848832), @@ -225,7 +225,7 @@ mod tests { references: Vec::new(), }; - let builtins: Vec<&'static str> = Vec::new(); + let builtins: Vec = Vec::new(); let data: Vec = vec![ mayberelocatable!(5189976364521848832), @@ -285,7 +285,7 @@ mod tests { ) .expect("Failed to deserialize program"); - let builtins: Vec<&'static str> = Vec::new(); + let builtins: Vec = Vec::new(); let data: Vec = vec![ mayberelocatable!(5189976364521848832), mayberelocatable!(1000), @@ -369,7 +369,7 @@ mod tests { ) .expect("Failed to deserialize program"); - let builtins: Vec<&'static str> = Vec::new(); + let builtins: Vec = Vec::new(); let error_message_attributes: Vec = vec![Attribute { name: String::from("error_message"), diff --git a/src/utils.rs b/src/utils.rs index 8e9db41827..2193905a2f 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -533,12 +533,12 @@ mod test { }, hint_processor_definition::{HintProcessor, HintReference}, }, - serde::deserialize_program::ReferenceManager, + serde::deserialize_program::{BuiltinName, ReferenceManager}, types::{exec_scope::ExecutionScopes, program::Program, relocatable::MaybeRelocatable}, utils::test_utils::*, vm::{ - errors::memory_errors::MemoryError, runners::builtin_runner::RANGE_CHECK_BUILTIN_NAME, - trace::trace_entry::TraceEntry, vm_core::VirtualMachine, vm_memory::memory::Memory, + errors::memory_errors::MemoryError, trace::trace_entry::TraceEntry, + vm_core::VirtualMachine, vm_memory::memory::Memory, }, }; use felt::Felt; @@ -895,7 +895,7 @@ mod test { #[test] fn program_macro_with_builtin() { let program = Program { - builtins: vec![RANGE_CHECK_BUILTIN_NAME], + builtins: vec![BuiltinName::range_check], prime: "0x800000000000011000000000000000000000000000000000000000000000001".to_string(), data: Vec::new(), constants: HashMap::new(), @@ -911,13 +911,13 @@ mod test { instruction_locations: None, }; - assert_eq!(program, program![RANGE_CHECK_BUILTIN_NAME]) + assert_eq!(program, program![BuiltinName::range_check]) } #[test] fn program_macro_custom_definition() { let program = Program { - builtins: vec![RANGE_CHECK_BUILTIN_NAME], + builtins: vec![BuiltinName::range_check], prime: "0x800000000000011000000000000000000000000000000000000000000000001".to_string(), data: Vec::new(), constants: HashMap::new(), @@ -935,7 +935,7 @@ mod test { assert_eq!( program, - program!(builtins = vec![RANGE_CHECK_BUILTIN_NAME], main = Some(2),) + program!(builtins = vec![BuiltinName::range_check], main = Some(2),) ) } } diff --git a/src/vm/runners/builtin_runner/bitwise.rs b/src/vm/runners/builtin_runner/bitwise.rs index d4f5bc33ff..d72b6e4b7e 100644 --- a/src/vm/runners/builtin_runner/bitwise.rs +++ b/src/vm/runners/builtin_runner/bitwise.rs @@ -228,8 +228,8 @@ impl BitwiseBuiltinRunner { mod tests { use super::*; use crate::relocatable; + use crate::serde::deserialize_program::BuiltinName; use crate::vm::errors::memory_errors::MemoryError; - use crate::vm::runners::builtin_runner::HASH_BUILTIN_NAME; use crate::vm::vm_memory::memory::Memory; use crate::vm::{runners::builtin_runner::BuiltinRunner, vm_core::VirtualMachine}; use crate::{ @@ -363,7 +363,7 @@ mod tests { vm.segments.segment_used_sizes = Some(vec![0]); let program = program!( - builtins = vec![BITWISE_BUILTIN_NAME], + builtins = vec![BuiltinName::bitwise], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -406,7 +406,7 @@ mod tests { let mut vm = vm!(); let program = program!( - builtins = vec![HASH_BUILTIN_NAME, BITWISE_BUILTIN_NAME], + builtins = vec![BuiltinName::pedersen, BuiltinName::bitwise], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), diff --git a/src/vm/runners/builtin_runner/ec_op.rs b/src/vm/runners/builtin_runner/ec_op.rs index 152df6dd8c..c4105e14e5 100644 --- a/src/vm/runners/builtin_runner/ec_op.rs +++ b/src/vm/runners/builtin_runner/ec_op.rs @@ -325,11 +325,11 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; + use crate::serde::deserialize_program::BuiltinName; use crate::types::program::Program; use crate::utils::{test_utils::*, CAIRO_PRIME}; use crate::vm::errors::cairo_run_errors::CairoRunError; use crate::vm::errors::vm_errors::VirtualMachineError; - use crate::vm::runners::builtin_runner::HASH_BUILTIN_NAME; use crate::vm::runners::cairo_runner::CairoRunner; use crate::vm::vm_memory::memory::Memory; use crate::vm::{ @@ -457,7 +457,7 @@ mod tests { vm.segments.segment_used_sizes = Some(vec![0]); let program = program!( - builtins = vec![HASH_BUILTIN_NAME], + builtins = vec![BuiltinName::pedersen], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -499,7 +499,7 @@ mod tests { let mut vm = vm!(); let program = program!( - builtins = vec![EC_OP_BUILTIN_NAME], + builtins = vec![BuiltinName::ec_op], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), diff --git a/src/vm/runners/builtin_runner/hash.rs b/src/vm/runners/builtin_runner/hash.rs index 599f21363c..8afd9cd200 100644 --- a/src/vm/runners/builtin_runner/hash.rs +++ b/src/vm/runners/builtin_runner/hash.rs @@ -215,6 +215,7 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; + use crate::serde::deserialize_program::BuiltinName; use crate::types::program::Program; use crate::utils::test_utils::*; use crate::vm::runners::cairo_runner::CairoRunner; @@ -341,7 +342,7 @@ mod tests { vm.segments.segment_used_sizes = Some(vec![0]); let program = program!( - builtins = vec![EC_OP_BUILTIN_NAME], + builtins = vec![BuiltinName::ec_op], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -384,7 +385,7 @@ mod tests { let mut vm = vm!(); let program = program!( - builtins = vec![EC_OP_BUILTIN_NAME], + builtins = vec![BuiltinName::ec_op], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), diff --git a/src/vm/runners/builtin_runner/mod.rs b/src/vm/runners/builtin_runner/mod.rs index 78e1b95677..a149af402f 100644 --- a/src/vm/runners/builtin_runner/mod.rs +++ b/src/vm/runners/builtin_runner/mod.rs @@ -438,6 +438,7 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; + use crate::serde::deserialize_program::BuiltinName; use crate::types::instance_definitions::ecdsa_instance_def::EcdsaInstanceDef; use crate::types::instance_definitions::keccak_instance_def::KeccakInstanceDef; use crate::types::program::Program; @@ -634,7 +635,7 @@ mod tests { let mut vm = vm!(); let program = program!( - builtins = vec![BITWISE_BUILTIN_NAME], + builtins = vec![BuiltinName::bitwise], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -677,7 +678,7 @@ mod tests { let mut vm = vm!(); let program = program!( - builtins = vec![EC_OP_BUILTIN_NAME], + builtins = vec![BuiltinName::ec_op], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -720,7 +721,7 @@ mod tests { let mut vm = vm!(); let program = program!( - builtins = vec![HASH_BUILTIN_NAME], + builtins = vec![BuiltinName::pedersen], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -763,7 +764,7 @@ mod tests { let mut vm = vm!(); let program = program!( - builtins = vec![RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::range_check], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), diff --git a/src/vm/runners/builtin_runner/range_check.rs b/src/vm/runners/builtin_runner/range_check.rs index edb5e34f46..2f3256eb02 100644 --- a/src/vm/runners/builtin_runner/range_check.rs +++ b/src/vm/runners/builtin_runner/range_check.rs @@ -248,6 +248,7 @@ impl RangeCheckBuiltinRunner { mod tests { use super::*; use crate::relocatable; + use crate::serde::deserialize_program::BuiltinName; use crate::vm::vm_memory::memory::Memory; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -375,7 +376,7 @@ mod tests { vm.segments.segment_used_sizes = Some(vec![0]); let program = program!( - builtins = vec![RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::range_check], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -418,7 +419,7 @@ mod tests { let mut vm = vm!(); let program = program!( - builtins = vec![RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::range_check], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index 8f210c33dd..fd5e6d67ef 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -1,7 +1,7 @@ use crate::{ hint_processor::hint_processor_definition::{HintProcessor, HintReference}, math_utils::safe_div_usize, - serde::deserialize_program::OffsetValue, + serde::deserialize_program::{BuiltinName, OffsetValue}, types::{ errors::{math_errors::MathError, program_errors::ProgramError}, exec_scope::ExecutionScopes, @@ -46,10 +46,7 @@ use std::{ ops::{Add, Sub}, }; -use super::builtin_runner::{ - KeccakBuiltinRunner, BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, - KECCAK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, -}; +use super::builtin_runner::{KeccakBuiltinRunner, OUTPUT_BUILTIN_NAME}; #[derive(Clone, Debug, Eq, PartialEq)] pub enum CairoArg { @@ -134,13 +131,13 @@ impl CairoRunner { pub fn initialize_builtins(&self, vm: &mut VirtualMachine) -> Result<(), RunnerError> { let builtin_ordered_list = vec![ - OUTPUT_BUILTIN_NAME, - HASH_BUILTIN_NAME, - RANGE_CHECK_BUILTIN_NAME, - SIGNATURE_BUILTIN_NAME, - BITWISE_BUILTIN_NAME, - EC_OP_BUILTIN_NAME, - KECCAK_BUILTIN_NAME, + BuiltinName::output, + BuiltinName::pedersen, + BuiltinName::range_check, + BuiltinName::ecdsa, + BuiltinName::bitwise, + BuiltinName::ec_op, + BuiltinName::keccak, ]; if !is_subsequence(&self.program.builtins, &builtin_ordered_list) { return Err(RunnerError::DisorderedBuiltins); @@ -148,30 +145,30 @@ impl CairoRunner { let mut builtin_runners = Vec::<(&'static str, BuiltinRunner)>::new(); if self.layout.builtins.output { - let included = self.program.builtins.contains(&OUTPUT_BUILTIN_NAME); + let included = self.program.builtins.contains(&BuiltinName::output); if included || self.proof_mode { builtin_runners.push(( - OUTPUT_BUILTIN_NAME, + BuiltinName::output.name(), OutputBuiltinRunner::new(included).into(), )); } } if let Some(instance_def) = self.layout.builtins.pedersen.as_ref() { - let included = self.program.builtins.contains(&HASH_BUILTIN_NAME); + let included = self.program.builtins.contains(&BuiltinName::pedersen); if included || self.proof_mode { builtin_runners.push(( - HASH_BUILTIN_NAME, + BuiltinName::pedersen.name(), HashBuiltinRunner::new(instance_def.ratio, included).into(), )); } } if let Some(instance_def) = self.layout.builtins.range_check.as_ref() { - let included = self.program.builtins.contains(&RANGE_CHECK_BUILTIN_NAME); + let included = self.program.builtins.contains(&BuiltinName::range_check); if included || self.proof_mode { builtin_runners.push(( - RANGE_CHECK_BUILTIN_NAME, + BuiltinName::range_check.name(), RangeCheckBuiltinRunner::new( instance_def.ratio, instance_def.n_parts, @@ -183,40 +180,40 @@ impl CairoRunner { } if let Some(instance_def) = self.layout.builtins.ecdsa.as_ref() { - let included = self.program.builtins.contains(&SIGNATURE_BUILTIN_NAME); + let included = self.program.builtins.contains(&BuiltinName::ecdsa); if included || self.proof_mode { builtin_runners.push(( - SIGNATURE_BUILTIN_NAME, + BuiltinName::ecdsa.name(), SignatureBuiltinRunner::new(instance_def, included).into(), )); } } if let Some(instance_def) = self.layout.builtins.bitwise.as_ref() { - let included = self.program.builtins.contains(&BITWISE_BUILTIN_NAME); + let included = self.program.builtins.contains(&BuiltinName::bitwise); if included || self.proof_mode { builtin_runners.push(( - BITWISE_BUILTIN_NAME, + BuiltinName::bitwise.name(), BitwiseBuiltinRunner::new(instance_def, included).into(), )); } } if let Some(instance_def) = self.layout.builtins.ec_op.as_ref() { - let included = self.program.builtins.contains(&EC_OP_BUILTIN_NAME); + let included = self.program.builtins.contains(&BuiltinName::ec_op); if included || self.proof_mode { builtin_runners.push(( - EC_OP_BUILTIN_NAME, + BuiltinName::ec_op.name(), EcOpBuiltinRunner::new(instance_def, included).into(), )); } } if let Some(instance_def) = self.layout.builtins.keccak.as_ref() { - let included = self.program.builtins.contains(&KECCAK_BUILTIN_NAME); + let included = self.program.builtins.contains(&BuiltinName::keccak); if included || self.proof_mode { builtin_runners.push(( - KECCAK_BUILTIN_NAME, + BuiltinName::keccak.name(), KeccakBuiltinRunner::new(instance_def, included).into(), )); } @@ -224,16 +221,20 @@ impl CairoRunner { let inserted_builtins = builtin_runners .iter() - .map(|x| &x.0) - .collect::>(); - let program_builtins: HashSet<&&str> = - self.program.builtins.iter().collect::>(); + .map(|x| x.0) + .collect::>(); + let program_builtins = self + .program + .builtins + .iter() + .map(|builtin_name| builtin_name.name()) + .collect::>(); // Get the builtins that belong to the program but weren't inserted (those who dont belong to the instance) if !program_builtins.is_subset(&inserted_builtins) { return Err(RunnerError::NoBuiltinForInstance( program_builtins .difference(&inserted_builtins) - .map(|x| **x) + .copied() .collect(), self.layout._name.clone(), )); @@ -247,48 +248,47 @@ impl CairoRunner { // Values extracted from here: https://github.com/starkware-libs/cairo-lang/blob/4fb83010ab77aa7ead0c9df4b0c05e030bc70b87/src/starkware/cairo/common/cairo_function_runner.py#L28 fn initialize_all_builtins(&self, vm: &mut VirtualMachine) -> Result<(), RunnerError> { let starknet_preset_builtins = vec![ - HASH_BUILTIN_NAME, - RANGE_CHECK_BUILTIN_NAME, - OUTPUT_BUILTIN_NAME, - SIGNATURE_BUILTIN_NAME, - BITWISE_BUILTIN_NAME, - EC_OP_BUILTIN_NAME, - KECCAK_BUILTIN_NAME, + BuiltinName::pedersen, + BuiltinName::range_check, + BuiltinName::output, + BuiltinName::ecdsa, + BuiltinName::bitwise, + BuiltinName::ec_op, + BuiltinName::keccak, ]; - fn initialize_builtin(name: &'static str, vm: &mut VirtualMachine) { + fn initialize_builtin(name: BuiltinName, vm: &mut VirtualMachine) { match name { - HASH_BUILTIN_NAME => vm + BuiltinName::pedersen => vm .builtin_runners - .push((name, HashBuiltinRunner::new(32, true).into())), - RANGE_CHECK_BUILTIN_NAME => vm + .push((name.name(), HashBuiltinRunner::new(32, true).into())), + BuiltinName::range_check => vm .builtin_runners - .push((name, RangeCheckBuiltinRunner::new(1, 8, true).into())), - OUTPUT_BUILTIN_NAME => vm + .push((name.name(), RangeCheckBuiltinRunner::new(1, 8, true).into())), + BuiltinName::output => vm .builtin_runners - .push((name, OutputBuiltinRunner::new(true).into())), - SIGNATURE_BUILTIN_NAME => vm.builtin_runners.push(( - name, + .push((name.name(), OutputBuiltinRunner::new(true).into())), + BuiltinName::ecdsa => vm.builtin_runners.push(( + name.name(), SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(1), true).into(), )), - BITWISE_BUILTIN_NAME => vm.builtin_runners.push(( - name, + BuiltinName::bitwise => vm.builtin_runners.push(( + name.name(), BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(1), true).into(), )), - EC_OP_BUILTIN_NAME => vm.builtin_runners.push(( - name, + BuiltinName::ec_op => vm.builtin_runners.push(( + name.name(), EcOpBuiltinRunner::new(&EcOpInstanceDef::new(1), true).into(), )), - KECCAK_BUILTIN_NAME => vm.builtin_runners.push(( - name, + BuiltinName::keccak => vm.builtin_runners.push(( + name.name(), EcOpBuiltinRunner::new(&EcOpInstanceDef::new(1), true).into(), )), - _ => {} } } for builtin_name in &self.program.builtins { - initialize_builtin(builtin_name, vm); + initialize_builtin(*builtin_name, vm); } for builtin_name in starknet_preset_builtins { if !self.program.builtins.contains(&builtin_name) { @@ -502,7 +502,7 @@ impl CairoRunner { &self.program.constants } - pub fn get_program_builtins(&self) -> &Vec<&'static str> { + pub fn get_program_builtins(&self) -> &Vec { &self.program.builtins } @@ -1104,7 +1104,9 @@ impl CairoRunner { .iter_mut() .rev() .filter(|(builtin_name, _builtin_runner)| { - self.get_program_builtins().contains(builtin_name) + self.get_program_builtins() + .iter() + .any(|bn| bn.name() == *builtin_name) }) { stack_ptr = runner.final_stack(&vm.segments, stack_ptr)? @@ -1202,6 +1204,10 @@ impl Sub for ExecutionResources { #[cfg(test)] mod tests { use super::*; + use crate::vm::runners::builtin_runner::{ + BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, KECCAK_BUILTIN_NAME, + RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, + }; use crate::vm::vm_memory::memory::MemoryCell; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ @@ -1223,7 +1229,7 @@ mod tests { #[test] fn check_memory_usage_ok_case() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::range_check, BuiltinName::output]; let cairo_runner = cairo_runner!(program); let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1257,7 +1263,7 @@ mod tests { #[test] fn initialize_builtins_with_disordered_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::range_check, BuiltinName::output]; let cairo_runner = cairo_runner!(program); let mut vm = vm!(); assert!(cairo_runner.initialize_builtins(&mut vm).is_err()); @@ -1266,7 +1272,7 @@ mod tests { #[test] fn create_cairo_runner_with_ordered_but_missing_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME]; + let program = program![BuiltinName::output, BuiltinName::ecdsa]; //We only check that the creation doesnt panic let _cairo_runner = cairo_runner!(program); } @@ -1274,7 +1280,7 @@ mod tests { #[test] fn initialize_segments_with_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); let program_base = Some(Relocatable { @@ -1307,7 +1313,7 @@ mod tests { #[test] fn initialize_segments_no_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); cairo_runner.initialize_builtins(&mut vm).unwrap(); @@ -1335,7 +1341,7 @@ mod tests { #[test] fn initialize_state_empty_data_and_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); cairo_runner.program_base = Some(relocatable!(1, 0)); @@ -1356,7 +1362,7 @@ mod tests { fn initialize_state_some_data_empty_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME], + builtins = vec![BuiltinName::output], data = vec_data!((4), (6)), ); let mut cairo_runner = cairo_runner!(program); @@ -1377,7 +1383,7 @@ mod tests { #[test] fn initialize_state_empty_data_some_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); for _ in 0..3 { @@ -1393,7 +1399,7 @@ mod tests { #[test] fn initialize_state_no_program_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); for _ in 0..2 { @@ -1414,7 +1420,7 @@ mod tests { #[should_panic] fn initialize_state_no_execution_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); for _ in 0..2 { @@ -1431,7 +1437,7 @@ mod tests { #[test] fn initialize_function_entrypoint_empty_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); for _ in 0..2 { @@ -1452,7 +1458,7 @@ mod tests { #[test] fn initialize_function_entrypoint_some_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); for _ in 0..2 { @@ -1479,7 +1485,7 @@ mod tests { #[should_panic] fn initialize_function_entrypoint_no_execution_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); let stack = vec![MaybeRelocatable::from(Felt::new(7_i32))]; @@ -1493,7 +1499,7 @@ mod tests { #[should_panic] fn initialize_main_entrypoint_no_main() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); cairo_runner.initialize_main_entrypoint(&mut vm).unwrap(); @@ -1550,7 +1556,7 @@ mod tests { #[test] fn initialize_vm_with_range_check_valid() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program!(builtins = vec![RANGE_CHECK_BUILTIN_NAME], main = Some(1),); + let program = program!(builtins = vec![BuiltinName::range_check], main = Some(1),); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); cairo_runner.initial_pc = Some(relocatable!(0, 1)); @@ -1578,7 +1584,7 @@ mod tests { #[test] fn initialize_vm_with_range_check_invalid() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program!(builtins = vec![RANGE_CHECK_BUILTIN_NAME], main = Some(1),); + let program = program!(builtins = vec![BuiltinName::range_check], main = Some(1),); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); cairo_runner.initial_pc = Some(relocatable!(0, 1)); @@ -1685,7 +1691,7 @@ mod tests { */ fn initialization_phase_output_builtin() { let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME], + builtins = vec![BuiltinName::output], data = vec_data!( (4612671182993129469_u64), (5198983563776393216_u64), @@ -1768,7 +1774,7 @@ mod tests { */ fn initialization_phase_range_check_builtin() { let program = program!( - builtins = vec![RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::range_check], data = vec_data!( (4612671182993129469_u64), (5189976364521848832_u64), @@ -1932,7 +1938,7 @@ mod tests { fn initialize_and_run_range_check_builtin() { //Initialization Phase let program = program!( - builtins = vec![RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::range_check], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -2043,7 +2049,7 @@ mod tests { fn initialize_and_run_output_builtin() { //Initialization Phase let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME], + builtins = vec![BuiltinName::output], data = vec_data!( (4612671182993129469_i64), (5198983563776393216_i64), @@ -2171,7 +2177,7 @@ mod tests { fn initialize_and_run_output_range_check_builtin() { //Initialization Phase let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::output, BuiltinName::range_check], data = vec_data!( (4612671182993129469_i64), (5198983563776393216_i64), @@ -2423,7 +2429,7 @@ mod tests { */ fn initialize_run_and_relocate_output_builtin() { let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME], + builtins = vec![BuiltinName::output], data = vec_data!( (4612671182993129469_i64), (5198983563776393216_i64), @@ -2558,7 +2564,7 @@ mod tests { */ fn relocate_trace_output_builtin() { let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME], + builtins = vec![BuiltinName::output], data = vec_data!( (4612671182993129469_i64), (5198983563776393216_i64), @@ -2702,7 +2708,7 @@ mod tests { #[test] fn write_output_from_preset_memory() { - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); cairo_runner.initialize_builtins(&mut vm).unwrap(); @@ -2731,7 +2737,7 @@ mod tests { fn write_output_from_program() { //Initialization Phase let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME], + builtins = vec![BuiltinName::output], data = vec_data!( (4612671182993129469_i64), (5198983563776393216_i64), @@ -2787,7 +2793,7 @@ mod tests { fn write_output_from_program_gap_relocatable_output() { //Initialization Phase let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME], + builtins = vec![BuiltinName::output], data = vec_data!( (4612671187288162301), (5198983563776458752), @@ -2819,7 +2825,7 @@ mod tests { #[test] fn write_output_from_preset_memory_neg_output() { - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); cairo_runner.initialize_builtins(&mut vm).unwrap(); @@ -2844,7 +2850,7 @@ mod tests { fn write_output_unordered_builtins() { //Initialization Phase let program = program!( - builtins = vec![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME], + builtins = vec![BuiltinName::output, BuiltinName::bitwise], data = vec_data!( (4612671182993129469_i64), (5198983563776393216_i64), @@ -2905,11 +2911,11 @@ mod tests { #[test] fn insert_all_builtins_in_order() { let program = program![ - OUTPUT_BUILTIN_NAME, - HASH_BUILTIN_NAME, - RANGE_CHECK_BUILTIN_NAME, - BITWISE_BUILTIN_NAME, - EC_OP_BUILTIN_NAME + BuiltinName::output, + BuiltinName::pedersen, + BuiltinName::range_check, + BuiltinName::bitwise, + BuiltinName::ec_op ]; let cairo_runner = cairo_runner!(program); let mut vm = vm!(); @@ -2943,7 +2949,7 @@ mod tests { */ fn run_for_steps() { let program = program!( - builtins = vec![RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::range_check], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -3009,7 +3015,7 @@ mod tests { */ fn run_until_steps() { let program = program!( - builtins = vec![RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::range_check], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -3081,7 +3087,7 @@ mod tests { /// step reaches a power of two, or an error occurs. fn run_until_next_power_of_2() { let program = program!( - builtins = vec![RANGE_CHECK_BUILTIN_NAME], + builtins = vec![BuiltinName::range_check], data = vec_data!( (4612671182993129469_i64), (5189976364521848832_i64), @@ -3774,7 +3780,7 @@ mod tests { #[test] fn get_initial_fp_can_be_obtained() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); for _ in 0..2 { @@ -3791,7 +3797,7 @@ mod tests { #[test] fn check_used_cells_valid_case() { - let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::range_check, BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -3855,7 +3861,7 @@ mod tests { #[test] fn check_used_cells_check_diluted_check_usage_error() { - let program = program![RANGE_CHECK_BUILTIN_NAME, OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::range_check, BuiltinName::output]; let cairo_runner = cairo_runner!(program); let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -3894,9 +3900,9 @@ mod tests { #[test] fn initialize_all_builtins_maintain_program_order() { let program = program![ - HASH_BUILTIN_NAME, - RANGE_CHECK_BUILTIN_NAME, - SIGNATURE_BUILTIN_NAME + BuiltinName::pedersen, + BuiltinName::range_check, + BuiltinName::ecdsa ]; let cairo_runner = cairo_runner!(program); @@ -3957,7 +3963,7 @@ mod tests { #[test] fn initialize_segments_incorrect_layout_plain_one_builtin() { - let program = program![OUTPUT_BUILTIN_NAME]; + let program = program![BuiltinName::output]; let mut vm = vm!(); let cairo_runner = cairo_runner!(program, "plain"); assert_eq!( @@ -3971,7 +3977,7 @@ mod tests { #[test] fn initialize_segments_incorrect_layout_plain_two_builtins() { - let program = program![OUTPUT_BUILTIN_NAME, HASH_BUILTIN_NAME]; + let program = program![BuiltinName::output, BuiltinName::pedersen]; let mut vm = vm!(); let cairo_runner = cairo_runner!(program, "plain"); assert_eq!( @@ -3985,7 +3991,7 @@ mod tests { #[test] fn initialize_segments_incorrect_layout_small_two_builtins() { - let program = program![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME]; + let program = program![BuiltinName::output, BuiltinName::bitwise]; let mut vm = vm!(); let cairo_runner = cairo_runner!(program, "small"); assert_eq!( @@ -4020,7 +4026,7 @@ mod tests { start = Some(0), end = Some(0), main = Some(8), - builtins = vec![OUTPUT_BUILTIN_NAME, EC_OP_BUILTIN_NAME], + builtins = vec![BuiltinName::output, BuiltinName::ec_op], ); let mut runner = cairo_runner!(program); runner.proof_mode = true; @@ -4044,7 +4050,7 @@ mod tests { start = Some(0), end = Some(0), main = Some(8), - builtins = vec![OUTPUT_BUILTIN_NAME, EC_OP_BUILTIN_NAME], + builtins = vec![BuiltinName::output, BuiltinName::ec_op], ); let runner = cairo_runner!(program); @@ -4200,7 +4206,7 @@ mod tests { #[test] fn read_return_values_updates_builtin_stop_ptr_one_builtin_empty() { - let mut program = program![OUTPUT_BUILTIN_NAME]; + let mut program = program![BuiltinName::output]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; //Program data len = 8 let mut cairo_runner = cairo_runner!(program, "all", true); @@ -4230,7 +4236,7 @@ mod tests { #[test] fn read_return_values_updates_builtin_stop_ptr_one_builtin_one_element() { - let mut program = program![OUTPUT_BUILTIN_NAME]; + let mut program = program![BuiltinName::output]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; //Program data len = 8 let mut cairo_runner = cairo_runner!(program, "all", true); @@ -4260,7 +4266,7 @@ mod tests { #[test] fn read_return_values_updates_builtin_stop_ptr_two_builtins() { - let mut program = program![OUTPUT_BUILTIN_NAME, BITWISE_BUILTIN_NAME]; + let mut program = program![BuiltinName::output, BuiltinName::bitwise]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; //Program data len = 8 let mut cairo_runner = cairo_runner!(program, "all", true); diff --git a/src/vm/security.rs b/src/vm/security.rs index 0ad3d994ed..611d547f78 100644 --- a/src/vm/security.rs +++ b/src/vm/security.rs @@ -81,10 +81,10 @@ pub fn verify_secure_runner( mod test { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; + use crate::serde::deserialize_program::BuiltinName; use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; use crate::vm::errors::memory_errors::MemoryError; - use crate::vm::runners::builtin_runner::RANGE_CHECK_BUILTIN_NAME; use crate::vm::vm_memory::memory::Memory; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{relocatable, types::program::Program, utils::test_utils::*}; @@ -138,7 +138,7 @@ mod test { #[test] fn verify_secure_runner_builtin_access_out_of_bounds() { - let program = program!(main = Some(0), builtins = vec![RANGE_CHECK_BUILTIN_NAME],); + let program = program!(main = Some(0), builtins = vec![BuiltinName::range_check],); let mut runner = cairo_runner!(program); let mut vm = vm!(); @@ -155,7 +155,7 @@ mod test { #[test] fn verify_secure_runner_builtin_access_correct() { - let program = program!(main = Some(0), builtins = vec![RANGE_CHECK_BUILTIN_NAME],); + let program = program!(main = Some(0), builtins = vec![BuiltinName::range_check],); let mut runner = cairo_runner!(program); let mut vm = vm!(); From cfeac09264bb5d2f598bc6d63157d5cb15befbb6 Mon Sep 17 00:00:00 2001 From: Mario Rugiero Date: Tue, 14 Mar 2023 18:26:58 -0300 Subject: [PATCH 07/15] WASM32 support with regression fix (#893) * Revert "Revert "Wasm32 support (#828)" (#891)" This reverts commit 23d941fd587354ea6ea82efd397baeed5c4f24bf. * Some optimizations * Fix mimalloc build for cairo-vm-cli * Use 3MiB for execution trace buffer --- .github/workflows/rust.yml | 8 + Cargo.lock | 326 ++-- Cargo.toml | 102 +- Makefile | 22 +- bench/criterion_benchmark.rs | 3 +- bench/iai_benchmark.rs | 84 +- bench/run_benchmarks.sh | 2 +- cairo-vm-cli/Cargo.toml | 16 + {src => cairo-vm-cli/src}/main.rs | 92 +- deps/parse-hyperlinks/Cargo.toml | 10 +- deps/parse-hyperlinks/src/lib.rs | 5 + felt/Cargo.toml | 19 +- felt/src/bigint_felt.rs | 35 +- felt/src/lib.rs | 65 +- src/cairo_run.rs | 257 ++- .../builtin_hint_processor/blake2s_hash.rs | 12 +- .../builtin_hint_processor/blake2s_utils.rs | 19 +- .../builtin_hint_processor_definition.rs | 28 +- .../cairo_keccak/keccak_hints.rs | 16 +- .../builtin_hint_processor/dict_hint_utils.rs | 36 +- .../builtin_hint_processor/dict_manager.rs | 16 +- .../find_element_hint.rs | 35 +- .../builtin_hint_processor/hint_utils.rs | 17 +- .../builtin_hint_processor/keccak_utils.rs | 3 +- .../builtin_hint_processor/math_utils.rs | 85 +- .../memcpy_hint_utils.rs | 8 +- .../builtin_hint_processor/memset_utils.rs | 13 +- .../builtin_hint_processor/pow_utils.rs | 12 +- .../secp/bigint_utils.rs | 12 +- .../builtin_hint_processor/secp/ec_utils.rs | 22 +- .../secp/field_utils.rs | 21 +- .../builtin_hint_processor/secp/secp_utils.rs | 12 +- .../builtin_hint_processor/secp/signature.rs | 20 +- .../builtin_hint_processor/segments.rs | 9 +- .../builtin_hint_processor/set.rs | 12 +- .../builtin_hint_processor/sha256_utils.rs | 9 +- .../builtin_hint_processor/signature.rs | 8 +- .../squash_dict_utils.rs | 70 +- .../builtin_hint_processor/uint256_utils.rs | 26 +- .../builtin_hint_processor/usort.rs | 10 +- .../hint_processor_definition.rs | 4 +- src/hint_processor/hint_processor_utils.rs | 20 +- src/lib.rs | 49 + src/math_utils.rs | 27 +- src/serde/deserialize_program.rs | 99 +- src/serde/deserialize_utils.rs | 33 +- {tests => src/tests}/bitwise_test.rs | 18 +- src/tests/cairo_run_test.rs | 1402 +++++++++++++++++ {tests => src/tests}/compare_vm_state.sh | 0 {tests => src/tests}/memory_comparator.py | 0 src/tests/mod.rs | 7 + {tests => src/tests}/pedersen_test.rs | 20 +- {tests => src/tests}/skip_instruction_test.rs | 21 +- {tests => src/tests}/struct_test.rs | 24 +- src/types/errors/math_errors.rs | 4 + src/types/errors/program_errors.rs | 16 +- src/types/exec_scope.rs | 18 +- .../bitwise_instance_def.rs | 7 + .../builtins_instance_def.rs | 10 + .../instance_definitions/cpu_instance_def.rs | 4 + .../diluted_pool_instance_def.rs | 5 + .../ec_op_instance_def.rs | 7 + .../ecdsa_instance_def.rs | 7 + .../keccak_instance_def.rs | 9 + .../pedersen_instance_def.rs | 7 + .../range_check_instance_def.rs | 7 + src/types/instruction.rs | 6 + src/types/layout.rs | 12 + src/types/program.rs | 62 +- src/types/relocatable.rs | 53 +- src/utils.rs | 81 +- src/vm/context/run_context.rs | 15 + src/vm/decoding/decoder.rs | 16 + src/vm/errors/cairo_run_errors.rs | 6 +- src/vm/errors/exec_scope_errors.rs | 3 + src/vm/errors/hint_errors.rs | 8 +- src/vm/errors/memory_errors.rs | 8 +- src/vm/errors/runner_errors.rs | 10 +- src/vm/errors/trace_errors.rs | 6 +- src/vm/errors/vm_errors.rs | 13 +- src/vm/errors/vm_exception.rs | 179 ++- src/vm/hooks.rs | 25 +- src/vm/runners/builtin_runner/bitwise.rs | 31 +- src/vm/runners/builtin_runner/ec_op.rs | 118 +- src/vm/runners/builtin_runner/hash.rs | 25 +- src/vm/runners/builtin_runner/keccak.rs | 39 +- src/vm/runners/builtin_runner/mod.rs | 79 + src/vm/runners/builtin_runner/output.rs | 26 +- src/vm/runners/builtin_runner/range_check.rs | 38 +- src/vm/runners/builtin_runner/signature.rs | 32 +- src/vm/runners/cairo_runner.rs | 310 ++-- src/vm/security.rs | 15 +- src/vm/trace/mod.rs | 8 +- src/vm/trace/trace_entry.rs | 8 + src/vm/vm_core.rs | 172 +- src/vm/vm_memory/memory.rs | 69 +- src/vm/vm_memory/memory_segments.rs | 53 +- src/with_alloc.rs | 15 + src/with_std.rs | 34 + src/without_std.rs | 24 + tests/cairo_run_test.rs | 267 ++-- 101 files changed, 4329 insertions(+), 939 deletions(-) create mode 100644 cairo-vm-cli/Cargo.toml rename {src => cairo-vm-cli/src}/main.rs (54%) rename {tests => src/tests}/bitwise_test.rs (94%) create mode 100644 src/tests/cairo_run_test.rs rename {tests => src/tests}/compare_vm_state.sh (100%) rename {tests => src/tests}/memory_comparator.py (100%) create mode 100644 src/tests/mod.rs rename {tests => src/tests}/pedersen_test.rs (87%) rename {tests => src/tests}/skip_instruction_test.rs (61%) rename {tests => src/tests}/struct_test.rs (63%) create mode 100644 src/with_alloc.rs create mode 100644 src/with_std.rs create mode 100644 src/without_std.rs diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 48e96fe5c8..49d668e8c2 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -28,6 +28,10 @@ jobs: uses: taiki-e/install-action@nextest - name: Install cargo-llvm-cov uses: taiki-e/install-action@cargo-llvm-cov + - name: Install wasm-bindgen-cli + uses: jetli/wasm-pack-action@v0.4.0 + with: + version: "v0.10.3" - name: Set up cargo cache uses: Swatinem/rust-cache@v2 @@ -62,6 +66,10 @@ jobs: run: pip install ecdsa fastecdsa sympy cairo-lang - name: Run tests run: make -j test + - name: Run tests no_std + run: make -j test-no_std + - name: Run wasm tests + run: make -j test-wasm - name: Compare trace and memory run: make -j compare_trace_memory - name: Compare trace and memory with proof mode diff --git a/Cargo.lock b/Cargo.lock index dabc670b47..69e2ea2656 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,23 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "ahash" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f" +dependencies = [ + "cfg-if", + "once_cell", + "version_check", +] + +[[package]] +name = "anyhow" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800" + [[package]] name = "ark-ff" version = "0.3.0" @@ -86,23 +103,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" [[package]] -name = "bigdecimal" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6aaf33151a6429fe9211d1b276eafdf70cdff28b071e76c0b0e1503221ea3744" +name = "bincode" +version = "2.0.0-rc.2" +source = "git+https://github.com/bincode-org/bincode.git?tag=v2.0.0-rc.2#6c219e9214bda2bdce1327db6ed7f66d2fa4bf02" dependencies = [ - "num-bigint", - "num-integer", - "num-traits", + "bincode_derive", + "serde", ] [[package]] -name = "bincode" -version = "1.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" +name = "bincode_derive" +version = "2.0.0-rc.2" +source = "git+https://github.com/bincode-org/bincode.git?tag=v2.0.0-rc.2#6c219e9214bda2bdce1327db6ed7f66d2fa4bf02" dependencies = [ - "serde", + "virtue", ] [[package]] @@ -126,15 +140,6 @@ version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" -[[package]] -name = "block-buffer" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4" -dependencies = [ - "generic-array", -] - [[package]] name = "block-buffer" version = "0.10.3" @@ -144,18 +149,6 @@ dependencies = [ "generic-array", ] -[[package]] -name = "bstr" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" -dependencies = [ - "lazy_static", - "memchr", - "regex-automata", - "serde", -] - [[package]] name = "bumpalo" version = "3.12.0" @@ -170,7 +163,7 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" [[package]] name = "cairo-felt" -version = "0.1.3" +version = "0.2.0" dependencies = [ "lazy_static", "num-bigint", @@ -182,14 +175,15 @@ dependencies = [ [[package]] name = "cairo-vm" -version = "0.1.3" +version = "0.2.0" dependencies = [ + "anyhow", "assert_matches", "bincode", "cairo-felt", - "clap 3.2.23", "criterion", "generic-array", + "hashbrown 0.13.2", "hex", "iai", "keccak", @@ -205,10 +199,24 @@ dependencies = [ "serde", "serde_bytes", "serde_json", - "sha2 0.10.6", + "sha2", "sha3", "starknet-crypto", "thiserror", + "thiserror-no-std", + "wasm-bindgen-test", +] + +[[package]] +name = "cairo-vm-cli" +version = "0.1.0" +dependencies = [ + "bincode", + "cairo-vm", + "clap 3.2.23", + "mimalloc", + "nom", + "thiserror", ] [[package]] @@ -288,6 +296,16 @@ dependencies = [ "os_str_bytes", ] +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + [[package]] name = "cpufeatures" version = "0.2.5" @@ -378,12 +396,11 @@ dependencies = [ [[package]] name = "crypto-bigint" -version = "0.3.2" +version = "0.4.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03c6a1d5fa1de37e071642dfa44ec552ca5b299adb128fab16138e24b548fd21" +checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef" dependencies = [ "generic-array", - "rand_core", "subtle", "zeroize", ] @@ -398,25 +415,14 @@ dependencies = [ "typenum", ] -[[package]] -name = "crypto-mac" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714" -dependencies = [ - "generic-array", - "subtle", -] - [[package]] name = "csv" -version = "1.1.6" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1" +checksum = "af91f40b7355f82b0a891f50e70399475945bb0b0da4f1700ce60761c9d3e359" dependencies = [ - "bstr", "csv-core", - "itoa 0.4.8", + "itoa", "ryu", "serde", ] @@ -456,15 +462,16 @@ version = "0.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f" dependencies = [ - "block-buffer 0.10.3", + "block-buffer", "crypto-common", + "subtle", ] [[package]] name = "either" -version = "1.8.0" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797" +checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91" [[package]] name = "envmnt" @@ -541,11 +548,21 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +[[package]] +name = "hashbrown" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" +dependencies = [ + "ahash", + "serde", +] + [[package]] name = "heck" -version = "0.4.0" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" [[package]] name = "hermit-abi" @@ -573,12 +590,11 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" [[package]] name = "hmac" -version = "0.11.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" dependencies = [ - "crypto-mac", - "digest 0.9.0", + "digest 0.10.6", ] [[package]] @@ -594,7 +610,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399" dependencies = [ "autocfg", - "hashbrown", + "hashbrown 0.12.3", ] [[package]] @@ -615,12 +631,6 @@ dependencies = [ "either", ] -[[package]] -name = "itoa" -version = "0.4.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" - [[package]] name = "itoa" version = "1.0.5" @@ -629,9 +639,9 @@ checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440" [[package]] name = "js-sys" -version = "0.3.60" +version = "0.3.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47" +checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730" dependencies = [ "wasm-bindgen", ] @@ -650,6 +660,9 @@ name = "lazy_static" version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" +dependencies = [ + "spin", +] [[package]] name = "libc" @@ -657,6 +670,12 @@ version = "0.2.139" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79" +[[package]] +name = "libm" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb" + [[package]] name = "libmimalloc-sys" version = "0.1.30" @@ -751,6 +770,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" dependencies = [ "autocfg", + "libm", ] [[package]] @@ -775,12 +795,6 @@ version = "11.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" -[[package]] -name = "opaque-debug" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" - [[package]] name = "os_str_bytes" version = "6.4.1" @@ -792,6 +806,7 @@ name = "parse-hyperlinks" version = "0.23.4" dependencies = [ "nom", + "wasm-bindgen-test", ] [[package]] @@ -879,9 +894,9 @@ dependencies = [ [[package]] name = "proptest" -version = "1.0.0" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e0d9cc07f18492d879586c92b485def06bc850da3118075cd45d50e9c95b0e5" +checksum = "29f1b898011ce9595050a68e60f90bad083ff2987a695a42357134c8381fba70" dependencies = [ "bit-set", "bitflags", @@ -895,6 +910,7 @@ dependencies = [ "regex-syntax", "rusty-fork", "tempfile", + "unarray", ] [[package]] @@ -997,12 +1013,6 @@ dependencies = [ "regex-syntax", ] -[[package]] -name = "regex-automata" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" - [[package]] name = "regex-syntax" version = "0.6.28" @@ -1020,9 +1030,9 @@ dependencies = [ [[package]] name = "rfc6979" -version = "0.1.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96ef608575f6392792f9ecf7890c00086591d29a83910939d430753f7c050525" +checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb" dependencies = [ "crypto-bigint", "hmac", @@ -1077,6 +1087,12 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + [[package]] name = "scopeguard" version = "1.1.0" @@ -1112,9 +1128,9 @@ dependencies = [ [[package]] name = "serde_bytes" -version = "0.11.8" +version = "0.11.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "718dc5fff5b36f99093fc49b280cfc96ce6fc824317783bff5a1fed0c7a64819" +checksum = "416bda436f9aab92e02c8e10d49a15ddd339cea90b6e340fe51ed97abb548294" dependencies = [ "serde", ] @@ -1146,24 +1162,11 @@ version = "1.0.91" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883" dependencies = [ - "itoa 1.0.5", + "itoa", "ryu", "serde", ] -[[package]] -name = "sha2" -version = "0.9.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" -dependencies = [ - "block-buffer 0.9.0", - "cfg-if", - "cpufeatures", - "digest 0.9.0", - "opaque-debug", -] - [[package]] name = "sha2" version = "0.10.6" @@ -1185,32 +1188,37 @@ dependencies = [ "keccak", ] +[[package]] +name = "spin" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" + [[package]] name = "starknet-crypto" version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be7d6b2c959fde2a10dbc31d54bdd0307eecb7ef6c05c23a0263e65b57b3e18a" +source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" dependencies = [ "crypto-bigint", + "hashbrown 0.13.2", "hex", "hmac", "num-bigint", "num-integer", "num-traits", "rfc6979", - "sha2 0.9.9", + "sha2", "starknet-crypto-codegen", "starknet-curve", "starknet-ff", - "thiserror", + "thiserror-no-std", "zeroize", ] [[package]] name = "starknet-crypto-codegen" version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6569d70430f0f6edc41f6820d00acf63356e6308046ca01e57eeac22ad258c47" +source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" dependencies = [ "starknet-curve", "starknet-ff", @@ -1220,8 +1228,7 @@ dependencies = [ [[package]] name = "starknet-curve" version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84be6079d3060fdbd8b5335574fef3d3783fa2f7ee6474d08ae0c1e4b0a29ba4" +source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" dependencies = [ "starknet-ff", ] @@ -1229,17 +1236,14 @@ dependencies = [ [[package]] name = "starknet-ff" version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5874510620214ebeac50915b01d67437d8ca10a6682b1de85b93cd01157b58eb" +source = "git+https://github.com/tdelabro/starknet-rs.git?branch=feature/manual-no-std-bigdecimal#13023c5bbd0426ce064bc31e21bc70b517818b85" dependencies = [ "ark-ff", - "bigdecimal", "crypto-bigint", "getrandom", "hex", - "num-bigint", "serde", - "thiserror", + "thiserror-no-std", ] [[package]] @@ -1335,6 +1339,26 @@ dependencies = [ "syn", ] +[[package]] +name = "thiserror-impl-no-std" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58e6318948b519ba6dc2b442a6d0b904ebfb8d411a3ad3e07843615a72249758" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror-no-std" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3ad459d94dd517257cc96add8a43190ee620011bb6e6cdc82dafd97dfafafea" +dependencies = [ + "thiserror-impl-no-std", +] + [[package]] name = "tinytemplate" version = "1.2.1" @@ -1366,6 +1390,12 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81" +[[package]] +name = "unarray" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" + [[package]] name = "unicode-ident" version = "1.0.6" @@ -1390,6 +1420,12 @@ version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" +[[package]] +name = "virtue" +version = "0.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b60dcd6a64dd45abf9bd426970c9843726da7fc08f44cd6fcebf68c21220a63" + [[package]] name = "wait-timeout" version = "0.2.0" @@ -1418,9 +1454,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] name = "wasm-bindgen" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268" +checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b" dependencies = [ "cfg-if", "wasm-bindgen-macro", @@ -1428,9 +1464,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-backend" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142" +checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9" dependencies = [ "bumpalo", "log", @@ -1441,11 +1477,23 @@ dependencies = [ "wasm-bindgen-shared", ] +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + [[package]] name = "wasm-bindgen-macro" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810" +checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -1453,9 +1501,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c" +checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6" dependencies = [ "proc-macro2", "quote", @@ -1466,9 +1514,33 @@ dependencies = [ [[package]] name = "wasm-bindgen-shared" -version = "0.2.83" +version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f" +checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d" + +[[package]] +name = "wasm-bindgen-test" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db36fc0f9fb209e88fb3642590ae0205bb5a56216dabd963ba15879fe53a30b" +dependencies = [ + "console_error_panic_hook", + "js-sys", + "scoped-tls", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-bindgen-test-macro", +] + +[[package]] +name = "wasm-bindgen-test-macro" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0734759ae6b3b1717d661fe4f016efcfb9828f5edb4520c18eaee05af3b43be9" +dependencies = [ + "proc-macro2", + "quote", +] [[package]] name = "web-sys" diff --git a/Cargo.toml b/Cargo.toml index 29b7f9e967..7794e20ad5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,62 +1,88 @@ [workspace] -members = [".", "felt", "./deps/parse-hyperlinks"] +members = [".", "felt", "cairo-vm-cli", "./deps/parse-hyperlinks"] [package] name = "cairo-vm" -version = "0.1.3" +version = "0.2.0" edition = "2021" license = "Apache-2.0" description = "Blazing fast Cairo interpreter" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [features] -default = ["with_mimalloc"] +default = ["std", "with_mimalloc"] with_mimalloc = ["mimalloc"] -# This feature will reference every test-oriented feature. +std = [ + "serde_json/std", + "serde_bytes/std", + "bincode/std", + "anyhow/std", + "starknet-crypto/std", + "parse-hyperlinks/std", + "felt/std", +] +alloc = [ + "serde_json/alloc", + "serde_bytes/alloc", + "starknet-crypto/alloc", + "parse-hyperlinks/alloc", + "felt/alloc", +] + + # Note that these features are not retro-compatible with the cairo Python VM. -test_utils = ["skip_next_instruction_hint", "hooks"] +test_utils = [ + "skip_next_instruction_hint", + "hooks", +] # This feature will reference every test-oriented feature skip_next_instruction_hint = [] hooks = [] [dependencies] mimalloc = { version = "0.1.29", default-features = false, optional = true } -num-bigint = { version = "0.4", features = ["serde"] } -num-traits = "0.2" -num-integer = "0.1.45" -serde = { version = "1.0", features = ["derive"] } -serde_bytes = "0.11.1" -serde_json = { version = "1.0", features = ["arbitrary_precision"] } -hex = "0.4.3" -bincode = "1.2.1" -starknet-crypto = "0.2.0" -clap = { version = "3.2.5", features = ["derive"] } -sha3 = "0.10.1" -rand_core = "0.6.4" -lazy_static = "1.4.0" -nom = "7" -sha2 = { version = "0.10.2", features = ["compress"] } -thiserror = "1.0.32" -generic-array = "0.14.6" -keccak = "0.1.2" +num-bigint = { version = "0.4", features = ["serde"], default-features = false } +num-traits = { version = "0.2", default-features = false } +num-integer = { version = "0.1.45", default-features = false } +serde = { version = "1.0", features = ["derive"], default-features = false } +serde_bytes = { version = "0.11.9", default-features = false } +serde_json = { version = "1.0", features = [ + "arbitrary_precision", +], default-features = false } +hex = { version = "0.4.3", default-features = false } +bincode = { tag = "v2.0.0-rc.2", git = "https://github.com/bincode-org/bincode.git", default-features = false, features = [ + "serde", +] } +starknet-crypto = { git = "https://github.com/tdelabro/starknet-rs.git", branch = "feature/manual-no-std-bigdecimal", default-features = false } +sha3 = { version = "0.10.1", default-features = false } +rand_core = { version = "0.6.4", default-features = false } +lazy_static = { version = "1.4.0", default-features = false, features = [ + "spin_no_std", +] } +nom = { version = "7", default-features = false } +sha2 = { version = "0.10.2", features = ["compress"], default-features = false } +generic-array = { version = "0.14.6", default-features = false } +keccak = { version = "0.1.2", default-features = false } +hashbrown = { version = "0.13.2", features = ["serde"] } +anyhow = { version = "1.0.69", default-features = false } +thiserror = { version = "1.0.32", default-features = false } +thiserror-no-std = "2.0.2" + # This crate has only one function `take_until_unbalanced` that is # very useful for our parsing purposes: # https://stackoverflow.com/questions/70630556/parse-allowing-nested-parentheses-in-nom # There is a proposal for extending nom::delimited to use this function: # https://github.com/Geal/nom/issues/1253 -parse-hyperlinks = { path = "./deps/parse-hyperlinks", version = "0.23.4" } -felt = { package = "cairo-felt", path = "./felt", version = "0.1.0" } +parse-hyperlinks = { path = "./deps/parse-hyperlinks", version = "0.23.4", default-features = false } +felt = { package = "cairo-felt", path = "./felt", default-features = false } -[dev-dependencies] -iai = "0.1" +[target.'cfg(target_arch = "wasm32")'.dev-dependencies] +wasm-bindgen-test = "0.3.34" assert_matches = "1.5.0" -[dev-dependencies.rusty-hook] -version = "0.11" - -[dev-dependencies.criterion] -version = "0.3" -features = ["html_reports"] +[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies] +iai = "0.1" +rusty-hook = "0.11" +assert_matches = "1.5.0" +criterion = { version = "0.3", features = ["html_reports"] } [[bench]] path = "bench/iai_benchmark.rs" @@ -68,11 +94,5 @@ path = "bench/criterion_benchmark.rs" name = "criterion_benchmark" harness = false -[[bin]] -name = "cairo-rs-run" -path = "src/main.rs" -bench = false -doc = false - [profile.release] lto = "fat" diff --git a/Makefile b/Makefile index f87c6cb330..5173f74552 100644 --- a/Makefile +++ b/Makefile @@ -32,7 +32,7 @@ $(TEST_PROOF_DIR)/%.json: $(TEST_PROOF_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_PROOF_DIR):$(PROOF_BENCH_DIR)" $< --output $@ --proof_mode $(TEST_PROOF_DIR)/%.rs.trace $(TEST_PROOF_DIR)/%.rs.memory: $(TEST_PROOF_DIR)/%.json $(RELBIN) - cargo llvm-cov run --release --no-report -- --layout all --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory + cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_PROOF_DIR)/%.trace $(TEST_PROOF_DIR)/%.memory: $(TEST_PROOF_DIR)/%.json cairo-run --layout all --proof_mode --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory @@ -68,7 +68,7 @@ $(TEST_DIR)/%.json: $(TEST_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_DIR):$(BENCH_DIR)" $< --output $@ $(TEST_DIR)/%.rs.trace $(TEST_DIR)/%.rs.memory: $(TEST_DIR)/%.json $(RELBIN) - cargo llvm-cov run --release --no-report -- --layout all $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory + cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_DIR)/%.trace $(TEST_DIR)/%.memory: $(TEST_DIR)/%.json cairo-run --layout all --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory @@ -107,7 +107,7 @@ $(RELBIN): build: $(RELBIN) run: - cargo run + cargo run -p cairo-vm-cli check: cargo check @@ -121,6 +121,10 @@ cairo-rs_trace: $(CAIRO_RS_TRACE) $(CAIRO_RS_MEM) test: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) cargo llvm-cov nextest --no-report --workspace --features test_utils +test-no_std: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) + cargo llvm-cov nextest --no-report --workspace --features test_utils --no-default-features --features alloc +test-wasm: $(COMPILED_PROOF_TESTS) $(COMPILED_TESTS) $(COMPILED_BAD_TESTS) $(COMPILED_NORETROCOMPAT_TESTS) + wasm-pack test --node --no-default-features --features alloc clippy: cargo clippy --tests --examples --all-features -- -D warnings @@ -148,22 +152,22 @@ compare_benchmarks: $(COMPILED_BENCHES) cd bench && ./run_benchmarks.sh compare_trace_memory: $(CAIRO_RS_TRACE) $(CAIRO_TRACE) $(CAIRO_RS_MEM) $(CAIRO_MEM) - cd tests; ./compare_vm_state.sh trace memory + cd src/tests; ./compare_vm_state.sh trace memory compare_trace: $(CAIRO_RS_TRACE) $(CAIRO_TRACE) - cd tests; ./compare_vm_state.sh trace + cd src/tests; ./compare_vm_state.sh trace compare_memory: $(CAIRO_RS_MEM) $(CAIRO_MEM) - cd tests; ./compare_vm_state.sh memory + cd src/tests; ./compare_vm_state.sh memory compare_trace_memory_proof: $(COMPILED_PROOF_TESTS) $(CAIRO_RS_TRACE_PROOF) $(CAIRO_TRACE_PROOF) $(CAIRO_RS_MEM_PROOF) $(CAIRO_MEM_PROOF) - cd tests; ./compare_vm_state.sh trace memory proof_mode + cd src/tests; ./compare_vm_state.sh trace memory proof_mode compare_trace_proof: $(CAIRO_RS_TRACE_PROOF) $(CAIRO_TRACE_PROOF) - cd tests; ./compare_vm_state.sh trace proof_mode + cd src/tests; ./compare_vm_state.sh trace proof_mode compare_memory_proof: $(CAIRO_RS_MEM_PROOF) $(CAIRO_MEM_PROOF) - cd tests; ./compare_vm_state.sh memory proof_mode + cd src/tests; ./compare_vm_state.sh memory proof_mode # Run with nightly enable the `doc_cfg` feature wich let us provide clear explaination about which parts of the code are behind a feature flag docs: diff --git a/bench/criterion_benchmark.rs b/bench/criterion_benchmark.rs index 4df2f75bc1..2ca326bbce 100644 --- a/bench/criterion_benchmark.rs +++ b/bench/criterion_benchmark.rs @@ -32,10 +32,11 @@ pub fn criterion_benchmarks(c: &mut Criterion) { ..cairo_vm::cairo_run::CairoRunConfig::default() }; for benchmark_name in build_bench_strings() { + let file_content = std::fs::read(Path::new(&benchmark_name.1)).unwrap(); c.bench_function(&benchmark_name.0, |b| { b.iter(|| { cairo_run::cairo_run( - black_box(Path::new(&benchmark_name.1)), + black_box(&file_content), &cairo_run_config, &mut hint_executor, ) diff --git a/bench/iai_benchmark.rs b/bench/iai_benchmark.rs index f956bf7c87..3ffb5e1839 100644 --- a/bench/iai_benchmark.rs +++ b/bench/iai_benchmark.rs @@ -1,10 +1,50 @@ -use std::path::Path; +use std::{ + fs::File, + io, + io::{BufWriter, Write}, +}; + +use bincode::enc::write::Writer; +use iai::{black_box, main}; use cairo_vm::{ cairo_run::*, hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, }; -use iai::{black_box, main}; + +// Copied from the CLI +struct FileWriter { + buf_writer: BufWriter, + bytes_written: usize, +} + +impl Writer for FileWriter { + fn write(&mut self, bytes: &[u8]) -> Result<(), bincode::error::EncodeError> { + self.buf_writer + .write_all(bytes) + .map_err(|e| bincode::error::EncodeError::Io { + inner: e, + index: self.bytes_written, + })?; + + self.bytes_written += bytes.len(); + + Ok(()) + } +} + +impl FileWriter { + fn new(buf_writer: BufWriter) -> Self { + Self { + buf_writer, + bytes_written: 0, + } + } + + fn flush(&mut self) -> Result<(), io::Error> { + self.buf_writer.flush() + } +} macro_rules! iai_bench_expand_prog { ($val: ident) => { @@ -12,35 +52,43 @@ macro_rules! iai_bench_expand_prog { let cairo_run_config = cairo_vm::cairo_run::CairoRunConfig { trace_enabled: true, layout: "all", - print_output: true, //FIXME: we need to distinguish the proof compiled programs //proof_mode: true, secure_run: Some(true), ..cairo_vm::cairo_run::CairoRunConfig::default() }; let mut hint_executor = BuiltinHintProcessor::new_empty(); - let program_path = Path::new(concat!( - "cairo_programs/benchmarks/", + + let program = include_bytes!(concat!( + "../cairo_programs/benchmarks/", stringify!($val), ".json" )); - let trace_path = Path::new("/dev/null"); - let memory_path = Path::new("/dev/null"); - - let runner = cairo_run( - black_box(program_path), - &cairo_run_config, - &mut hint_executor, - ) - .expect("cairo_run failed"); + let (runner, mut vm) = + cairo_run(black_box(program), &cairo_run_config, &mut hint_executor) + .expect("cairo_run failed"); + let trace_file = File::create("/dev/null").expect("open trace file"); + let mut trace_writer = FileWriter::new(BufWriter::new(trace_file)); let relocated_trace = runner.relocated_trace.as_ref().expect("relocation failed"); + write_encoded_trace( + black_box(relocated_trace.as_slice()), + black_box(&mut trace_writer), + ) + .expect("writing execution trace failed"); + trace_writer.flush().expect("flush trace"); - write_binary_trace(black_box(relocated_trace), black_box(&trace_path)) - .expect("writing execution trace failed"); + let memory_file = File::create("/dev/null").expect("open memory file"); + let mut memory_writer = FileWriter::new(BufWriter::new(memory_file)); + write_encoded_memory( + black_box(&runner.relocated_memory), + black_box(&mut memory_writer), + ) + .expect("writing relocated memory failed"); + memory_writer.flush().expect("flush memory"); - write_binary_memory(black_box(&runner.relocated_memory), black_box(&memory_path)) - .expect("writing relocated memory failed"); + vm.write_output(black_box(&mut String::new())) + .expect("writing output failed"); } }; } diff --git a/bench/run_benchmarks.sh b/bench/run_benchmarks.sh index 624b2e01d0..e5506de4c9 100755 --- a/bench/run_benchmarks.sh +++ b/bench/run_benchmarks.sh @@ -1,5 +1,5 @@ #!/usr/bin/env sh -tests_path="../cairo_programs/benchmarks" +tests_path="cairo_programs/benchmarks" set -e diff --git a/cairo-vm-cli/Cargo.toml b/cairo-vm-cli/Cargo.toml new file mode 100644 index 0000000000..d60e7410d9 --- /dev/null +++ b/cairo-vm-cli/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "cairo-vm-cli" +version = "0.1.0" +edition = "2021" + +[dependencies] +bincode = { tag = "v2.0.0-rc.2", git = "https://github.com/bincode-org/bincode.git" } +cairo-vm = { path = ".." } +clap = { version = "3.2.5", features = ["derive"] } +mimalloc = { version = "0.1.29", default-features = false, optional = true } +nom = "7" +thiserror = { version = "1.0.32" } + +[features] +default = ["with_mimalloc"] +with_mimalloc = ["cairo-vm/with_mimalloc", "mimalloc"] diff --git a/src/main.rs b/cairo-vm-cli/src/main.rs similarity index 54% rename from src/main.rs rename to cairo-vm-cli/src/main.rs index 363dc933aa..a5e74aa22c 100644 --- a/src/main.rs +++ b/cairo-vm-cli/src/main.rs @@ -1,11 +1,14 @@ #![deny(warnings)] -use cairo_vm::cairo_run; +use bincode::enc::write::Writer; +use cairo_vm::cairo_run::{self, EncodeTraceError}; use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use cairo_vm::vm::errors::cairo_run_errors::CairoRunError; -use cairo_vm::vm::errors::runner_errors::RunnerError; use cairo_vm::vm::errors::trace_errors::TraceError; +use cairo_vm::vm::errors::vm_errors::VirtualMachineError; use clap::{Parser, ValueHint}; +use std::io::{self, Write}; use std::path::PathBuf; +use thiserror::Error; #[cfg(feature = "with_mimalloc")] use mimalloc::MiMalloc; @@ -43,43 +46,100 @@ fn validate_layout(value: &str) -> Result<(), String> { } } -fn main() -> Result<(), CairoRunError> { +#[derive(Debug, Error)] +enum Error { + #[error("Failed to interact with the file system")] + IO(#[from] std::io::Error), + #[error("The cairo program execution failed")] + Runner(#[from] CairoRunError), + #[error(transparent)] + EncodeTrace(#[from] EncodeTraceError), + #[error(transparent)] + VirtualMachine(#[from] VirtualMachineError), +} + +struct FileWriter { + buf_writer: io::BufWriter, + bytes_written: usize, +} + +impl Writer for FileWriter { + fn write(&mut self, bytes: &[u8]) -> Result<(), bincode::error::EncodeError> { + self.buf_writer + .write_all(bytes) + .map_err(|e| bincode::error::EncodeError::Io { + inner: e, + index: self.bytes_written, + })?; + + self.bytes_written += bytes.len(); + + Ok(()) + } +} + +impl FileWriter { + fn new(buf_writer: io::BufWriter) -> Self { + Self { + buf_writer, + bytes_written: 0, + } + } + + fn flush(&mut self) -> io::Result<()> { + self.buf_writer.flush() + } +} + +fn main() -> Result<(), Error> { let args = Args::parse(); let trace_enabled = args.trace_file.is_some(); let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { entrypoint: &args.entrypoint, trace_enabled, - print_output: args.print_output, layout: &args.layout, proof_mode: args.proof_mode, secure_run: args.secure_run, }; - let cairo_runner = - match cairo_run::cairo_run(&args.filename, &cairo_run_config, &mut hint_executor) { + + let program_content = std::fs::read(args.filename).map_err(|e| Error::IO(e))?; + + let (cairo_runner, mut vm) = + match cairo_run::cairo_run(&program_content, &cairo_run_config, &mut hint_executor) { Ok(runner) => runner, Err(error) => { println!("{error}"); - return Err(error); + return Err(Error::Runner(error)); } }; + if args.print_output { + let mut output_buffer = "Program Output:\n".to_string(); + vm.write_output(&mut output_buffer)?; + print!("{output_buffer}"); + } + if let Some(trace_path) = args.trace_file { let relocated_trace = cairo_runner .relocated_trace - .as_ref() .ok_or(CairoRunError::Trace(TraceError::TraceNotEnabled))?; - match cairo_run::write_binary_trace(relocated_trace, &trace_path) { - Ok(()) => (), - Err(_e) => return Err(CairoRunError::Runner(RunnerError::WriteFail)), - } + + let trace_file = std::fs::File::create(trace_path)?; + let mut trace_writer = + FileWriter::new(io::BufWriter::with_capacity(3 * 1024 * 1024, trace_file)); + + cairo_run::write_encoded_trace(&relocated_trace, &mut trace_writer)?; + trace_writer.flush()?; } if let Some(memory_path) = args.memory_file { - match cairo_run::write_binary_memory(&cairo_runner.relocated_memory, &memory_path) { - Ok(()) => (), - Err(_e) => return Err(CairoRunError::Runner(RunnerError::WriteFail)), - } + let memory_file = std::fs::File::create(memory_path)?; + let mut memory_writer = + FileWriter::new(io::BufWriter::with_capacity(5 * 1024 * 1024, memory_file)); + + cairo_run::write_encoded_memory(&cairo_runner.relocated_memory, &mut memory_writer)?; + memory_writer.flush()?; } Ok(()) diff --git a/deps/parse-hyperlinks/Cargo.toml b/deps/parse-hyperlinks/Cargo.toml index b80392e2c7..9752d93471 100644 --- a/deps/parse-hyperlinks/Cargo.toml +++ b/deps/parse-hyperlinks/Cargo.toml @@ -12,4 +12,12 @@ description = "A Nom parser library for hyperlinks with markup." categories = ["command-line-utilities", "parser-implementations"] [dependencies] -nom= "7.1.1" +nom = { version = "7.1.1", default-features = false } + +[features] +default = ["std"] +std = ["nom/std"] +alloc = ["nom/alloc"] + +[target.'cfg(target_arch = "wasm32")'.dev-dependencies] +wasm-bindgen-test = "0.3.34" diff --git a/deps/parse-hyperlinks/src/lib.rs b/deps/parse-hyperlinks/src/lib.rs index cc1aa7af4c..8da099d0c5 100644 --- a/deps/parse-hyperlinks/src/lib.rs +++ b/deps/parse-hyperlinks/src/lib.rs @@ -1,4 +1,5 @@ #![allow(dead_code)] +#![cfg_attr(not(feature = "std"), no_std)] use nom::error::Error; use nom::error::ErrorKind; @@ -87,7 +88,11 @@ mod tests { use super::*; use nom::error::ErrorKind; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_take_until_unmatched() { assert_eq!(take_until_unbalanced('(', ')')("abc"), Ok(("", "abc"))); assert_eq!( diff --git a/felt/Cargo.toml b/felt/Cargo.toml index c21a8706fe..e1a7c221ac 100644 --- a/felt/Cargo.toml +++ b/felt/Cargo.toml @@ -1,18 +1,23 @@ [package] name = "cairo-felt" -version = "0.1.3" +version = "0.2.0" edition = "2021" license = "Apache-2.0" description = "Field elements representation for the Cairo VM" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[features] +default = ["std"] +std = [] +alloc = [] [dependencies] -num-integer = "0.1.45" -num-bigint = { version = "0.4", features = ["serde"] } -num-traits = "0.2.15" -lazy_static = "1.4.0" -serde = { version = "1.0", features = ["derive"] } +num-integer = { version = "0.1.45", default-features = false } +num-bigint = { version = "0.4", features = ["serde"], default-features = false } +num-traits = { version = "0.2.15", default-features = false } +lazy_static = { version = "1.4.0", default-features = false, features = [ + "spin_no_std", +] } +serde = { version = "1.0", features = ["derive"], default-features = false } [dev-dependencies] proptest = "1.0.0" diff --git a/felt/src/bigint_felt.rs b/felt/src/bigint_felt.rs index 8c2a9f8e4a..e0e24acd64 100644 --- a/felt/src/bigint_felt.rs +++ b/felt/src/bigint_felt.rs @@ -1,9 +1,8 @@ -use lazy_static::lazy_static; -use num_bigint::{BigInt, BigUint, ToBigInt, U64Digits}; -use num_integer::Integer; -use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; -use serde::{Deserialize, Serialize}; -use std::{ +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use alloc::{string::String, vec::Vec}; + +use core::{ + cmp, convert::Into, fmt, iter::Sum, @@ -17,6 +16,11 @@ use crate::{FeltOps, ParseFeltError}; pub const FIELD_HIGH: u128 = (1 << 123) + (17 << 64); // this is equal to 10633823966279327296825105735305134080 pub const FIELD_LOW: u128 = 1; +use lazy_static::lazy_static; +use num_bigint::{BigInt, BigUint, ToBigInt, U64Digits}; +use num_integer::Integer; +use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; +use serde::{Deserialize, Serialize}; lazy_static! { static ref CAIRO_PRIME_BIGUINT: BigUint = @@ -148,10 +152,12 @@ impl FeltOps for FeltBigInt { self.val.iter_u64_digits() } + #[cfg(any(feature = "std", feature = "alloc"))] fn to_signed_bytes_le(&self) -> Vec { self.val.to_bytes_le() } + #[cfg(any(feature = "std", feature = "alloc"))] fn to_bytes_be(&self) -> Vec { self.val.to_bytes_be() } @@ -171,6 +177,7 @@ impl FeltOps for FeltBigInt { Self::from(value) } + #[cfg(any(feature = "std", feature = "alloc"))] fn to_str_radix(&self, radix: u32) -> String { self.val.to_str_radix(radix) } @@ -627,7 +634,7 @@ impl Integer for FeltBigInt { } fn lcm(&self, other: &Self) -> Self { - Self::new(std::cmp::max(&self.val, &other.val)) + Self::new(cmp::max(&self.val, &other.val)) } fn mod_floor(&self, other: &Self) -> Self { @@ -829,8 +836,15 @@ mod tests { use super::*; use proptest::prelude::*; + #[cfg(all(not(feature = "std"), feature = "alloc"))] + use alloc::string::ToString; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] // Tests that the result of adding two zeros is zero. + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_zeros() { let a = FeltBigInt::::new(0); let b = FeltBigInt::new(0); @@ -840,6 +854,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of performing add assign with two zeros is zero. fn add_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -898,6 +913,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of multiplying two zeros is zero. fn mul_zeros() { let a = FeltBigInt::::new(0); @@ -908,6 +924,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of multiplying two zeros with assignment is zero. fn mul_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -919,6 +936,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of subtracting two zeros is zero. fn sub_zeros() { let a = FeltBigInt::::new(0); @@ -929,6 +947,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the result of subtracting two zeros with assignment is zero. fn sub_assign_zeros() { let mut a = FeltBigInt::::new(0); @@ -940,6 +959,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_usize_felt() { let a = FeltBigInt::::new(4u32); let b = FeltBigInt::new(2u32); @@ -949,6 +969,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the negative of zero is zero fn negate_zero() { let a = FeltBigInt::::new(0); diff --git a/felt/src/lib.rs b/felt/src/lib.rs index 8c13790d4a..ffc122fdab 100644 --- a/felt/src/lib.rs +++ b/felt/src/lib.rs @@ -1,3 +1,9 @@ +#![cfg_attr(not(feature = "std"), no_std)] +#[allow(unused_imports)] +#[macro_use] +#[cfg(all(not(feature = "std"), feature = "alloc"))] +pub extern crate alloc; + mod bigint_felt; use bigint_felt::{FeltBigInt, FIELD_HIGH, FIELD_LOW}; @@ -5,7 +11,8 @@ use num_bigint::{BigInt, BigUint, U64Digits}; use num_integer::Integer; use num_traits::{Bounded, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero}; use serde::{Deserialize, Serialize}; -use std::{ + +use core::{ convert::Into, fmt, iter::Sum, @@ -15,6 +22,9 @@ use std::{ }, }; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use alloc::{string::String, vec::Vec}; + pub const PRIME_STR: &str = "0x800000000000011000000000000000000000000000000000000000000000001"; // in decimal, this is equal to 3618502788666131213697322783095070105623107215331596699973092056135872020481 pub(crate) trait FeltOps { @@ -28,14 +38,17 @@ pub(crate) trait FeltOps { fn iter_u64_digits(&self) -> U64Digits; + #[cfg(any(feature = "std", feature = "alloc"))] fn to_signed_bytes_le(&self) -> Vec; + #[cfg(any(feature = "std", feature = "alloc"))] fn to_bytes_be(&self) -> Vec; fn parse_bytes(buf: &[u8], radix: u32) -> Option>; fn from_bytes_be(bytes: &[u8]) -> Self; + #[cfg(any(feature = "std", feature = "alloc"))] fn to_str_radix(&self, radix: u32) -> String; #[deprecated] @@ -138,9 +151,20 @@ impl Felt { pub fn iter_u64_digits(&self) -> U64Digits { self.value.iter_u64_digits() } + + pub fn to_le_bytes(&self) -> [u8; 32] { + let mut res: [u8; 32] = [0; 32]; + for (i, x) in self.iter_u64_digits().take(4).enumerate() { + res[8 * i..8 * (i + 1)].copy_from_slice(&x.to_le_bytes()); + } + res + } + + #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_signed_bytes_le(&self) -> Vec { self.value.to_signed_bytes_le() } + #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_bytes_be(&self) -> Vec { self.value.to_bytes_be() } @@ -154,6 +178,7 @@ impl Felt { value: FeltBigInt::from_bytes_be(bytes), } } + #[cfg(any(feature = "std", feature = "alloc"))] pub fn to_str_radix(&self, radix: u32) -> String { self.value.to_str_radix(radix) } @@ -824,6 +849,7 @@ assert_felt_impl!(Felt); #[cfg(test)] mod test { use super::*; + use core::cmp; use proptest::prelude::*; const FELT_PATTERN: &str = "(0|[1-9][0-9]*)"; @@ -832,6 +858,7 @@ mod test { proptest! { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a new felt doesn't fall outside the range [0, p]. // In this and some of the following tests, The value of {x} can be either [0] or a very large number, in order to try to overflow the value of {p} and thus ensure the modular arithmetic is working correctly. fn new_in_range(ref x in "(0|[1-9][0-9]*)") { @@ -841,6 +868,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a felt created using Felt::from_bytes_be doesn't fall outside the range [0, p]. // In this and some of the following tests, The value of {x} can be either [0] or a very large number, in order to try to overflow the value of {p} and thus ensure the modular arithmetic is working correctly. fn from_bytes_be_in_range(ref x in "(0|[1-9][0-9]*)") { @@ -851,6 +879,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that the negative of a felt doesn't fall outside the range [0, p]. fn neg_in_range(ref x in "(0|[1-9][0-9]*)") { let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -868,6 +897,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a subtraction between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn sub_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -881,6 +911,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a subtraction with assignment between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn sub_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -899,6 +930,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a multiplication between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn mul_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -912,6 +944,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 pairs of {x} and {y} values that are randomly generated each time tests are run, that a multiplication with assignment between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn mul_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -925,6 +958,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 pairs of {x} and {y} values that are randomly generated each time tests are run, that the result of the division of {x} by {y} is the inverse multiplicative of {x} --that is, multiplying the result by {y} returns the original number {x}. The values of {x} and {y} can be either [0] or a very large number. fn div_is_mul_inv(ref x in "(0|[1-9][0-9]*)", ref y in "[1-9][0-9]*") { let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -940,6 +974,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the left by {shift_amount} of bits (between 0 and 999) returns a result that is inside of the range [0, p]. fn shift_left_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ let value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); @@ -955,6 +990,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the right by {shift_amount} of bits (between 0 and 999) returns a result that is inside of the range [0, p]. fn shift_right_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ let value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); @@ -966,6 +1002,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the right by {shift_amount} of bits (between 0 and 999), with assignment, returns a result that is inside of the range [0, p]. // "With assignment" means that the result of the operation is autommatically assigned to the variable value, replacing its previous content. fn shift_right_assign_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ @@ -978,6 +1015,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitAnd operation between them returns a result that is inside of the range [0, p]. fn bitand_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -990,6 +1028,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitOr operation between them returns a result that is inside of the range [0, p]. fn bitor_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1001,6 +1040,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitXor operation between them returns a result that is inside of the range [0, p]. fn bitxor_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1012,6 +1052,7 @@ mod test { #[test] #[allow(deprecated)] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 values {x} that are randomly generated each time tests are run, that raising {x} to the {y}th power returns a result that is inside of the range [0, p]. fn pow_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "[0-9]{1,2}"){ let base = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1029,6 +1070,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a Sum operation between them returns a result that is inside of the range [0, p]. fn sum_in_range(ref x in "[1-9][0-9]*", ref y in "[0-9][0-9]*"){ let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); @@ -1041,6 +1083,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property test to check that the remainder of a division between 100 pairs of values {x} and {y},generated at random each time tests are run, falls in the range [0, p]. x and y can either take the value of 0 or a large integer. // In Cairo, the result of x / y is defined to always satisfy the equation (x / y) * y == x, so the remainder is 0 most of the time. fn rem_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { @@ -1059,15 +1102,17 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 Felts {x} generated at random each time tests are run, that converting them into the u64 type returns a result that is inside of the range [0, p]. fn from_u64_and_to_u64_primitive(x in any::()) { let x_felt:Felt = Felt::from_u64(x).unwrap(); let x_u64:u64 = Felt::to_u64(&x_felt).unwrap(); - prop_assert_eq!(x, x_u64); + prop_assert_eq!(x, x_u64); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_i64_and_to_i64_primitive(x in any::()) { let x: i64 = x as i64; let x_felt:Felt = Felt::from_i64(x).unwrap(); @@ -1082,16 +1127,17 @@ mod test { let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); let lcm = x.lcm(&y); - prop_assert!(lcm == std::cmp::max(x, y)); + prop_assert!(lcm == cmp::max(x, y)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property test to check that is_multiple_of(x, y) works. Since we're operating in a prime field, is_multiple_of // will always be true fn is_multiple_of_doesnt_panic(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); - prop_assert!(x.is_multiple_of(&y)); + let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + prop_assert!(x.is_multiple_of(&y)); } #[test] @@ -1293,6 +1339,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of adding two zeroes is zero fn sum_zeros_in_range() { let x = Felt::new(0); @@ -1302,6 +1349,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of multiplying two zeroes is zero fn mul_zeros_in_range() { let x = Felt::new(0); @@ -1311,6 +1359,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of performing a bit and operation between zeroes is zero fn bit_and_zeros_in_range() { let x = Felt::new(0); @@ -1320,6 +1369,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of perfforming a bit or operation between zeroes is zero fn bit_or_zeros_in_range() { let x = Felt::new(0); @@ -1329,6 +1379,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of perfforming a bit xor operation between zeroes is zero fn bit_xor_zeros_in_range() { let x = Felt::new(0); @@ -1338,6 +1389,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the maximum value a Felt can take is equal to (prime - 1) fn upper_bound() { let prime = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); @@ -1347,6 +1399,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Tests that the minimum value a Felt can take is equal to zero. fn lower_bound() { let zero = BigUint::zero(); diff --git a/src/cairo_run.rs b/src/cairo_run.rs index cb50860a0e..0b04800342 100644 --- a/src/cairo_run.rs +++ b/src/cairo_run.rs @@ -2,26 +2,24 @@ use crate::{ hint_processor::hint_processor_definition::HintProcessor, types::program::Program, vm::{ - errors::{ - cairo_run_errors::CairoRunError, runner_errors::RunnerError, vm_exception::VmException, - }, + errors::{cairo_run_errors::CairoRunError, vm_exception::VmException}, runners::cairo_runner::CairoRunner, security::verify_secure_runner, - trace::trace_entry::RelocatedTraceEntry, vm_core::VirtualMachine, }, }; + +use bincode::enc::write::Writer; use felt::Felt; -use std::{ - fs::File, - io::{self, BufWriter, Error, ErrorKind, Write}, - path::Path, -}; + +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(not(feature = "std"))] +use thiserror_no_std::Error; pub struct CairoRunConfig<'a> { pub entrypoint: &'a str, pub trace_enabled: bool, - pub print_output: bool, pub layout: &'a str, pub proof_mode: bool, pub secure_run: Option, @@ -32,7 +30,6 @@ impl<'a> Default for CairoRunConfig<'a> { CairoRunConfig { entrypoint: "main", trace_enabled: false, - print_output: false, layout: "plain", proof_mode: false, secure_run: None, @@ -41,14 +38,11 @@ impl<'a> Default for CairoRunConfig<'a> { } pub fn cairo_run( - path: &Path, + program_content: &[u8], cairo_run_config: &CairoRunConfig, hint_executor: &mut dyn HintProcessor, -) -> Result { - let program = match Program::from_file(path, Some(cairo_run_config.entrypoint)) { - Ok(program) => program, - Err(error) => return Err(CairoRunError::Program(error)), - }; +) -> Result<(CairoRunner, VirtualMachine), CairoRunError> { + let program = Program::from_bytes(program_content, Some(cairo_run_config.entrypoint))?; let secure_run = cairo_run_config .secure_run @@ -77,93 +71,88 @@ pub fn cairo_run( } cairo_runner.relocate(&mut vm)?; - if cairo_run_config.print_output { - write_output(&mut cairo_runner, &mut vm)?; - } - - Ok(cairo_runner) -} - -pub fn write_output( - cairo_runner: &mut CairoRunner, - vm: &mut VirtualMachine, -) -> Result<(), CairoRunError> { - let mut buffer = BufWriter::new(io::stdout()); - writeln!(&mut buffer, "Program Output: ") - .map_err(|_| CairoRunError::Runner(RunnerError::WriteFail))?; - cairo_runner.write_output(vm, &mut buffer)?; - buffer - .flush() - .map_err(|_| CairoRunError::Runner(RunnerError::WriteFail)) + Ok((cairo_runner, vm)) } -/// Writes a trace as a binary file. Bincode encodes to little endian by default and each trace -/// entry is composed of 3 usize values that are padded to always reach 64 bit size. -pub fn write_binary_trace( - relocated_trace: &[RelocatedTraceEntry], - trace_file: &Path, -) -> io::Result<()> { - let file = File::create(trace_file)?; - let mut buffer = BufWriter::new(file); +#[derive(Debug, Error)] +#[error("Failed to encode trace at position {0}, serialize error: {1}")] +pub struct EncodeTraceError(usize, bincode::error::EncodeError); + +/// Writes the trace binary representation. +/// +/// Bincode encodes to little endian by default and each trace entry is composed of +/// 3 usize values that are padded to always reach 64 bit size. +pub fn write_encoded_trace( + relocated_trace: &[crate::vm::trace::trace_entry::RelocatedTraceEntry], + dest: &mut impl Writer, +) -> Result<(), EncodeTraceError> { + /* + let mut serialized: [u8; 24] = [0; 24]; for (i, entry) in relocated_trace.iter().enumerate() { - bincode::serialize_into(&mut buffer, entry).map_err(|e| { - Error::new( - ErrorKind::Other, - format!("Failed to dump trace at position {i}, serialize error: {e}"), - ) - })?; + serialized[..8].copy_from_slice(&((entry.ap as u64).to_le_bytes())); + serialized[8..16].copy_from_slice(&((entry.fp as u64).to_le_bytes())); + serialized[16..].copy_from_slice(&((entry.pc as u64).to_le_bytes())); + dest.write(&serialized) + .map_err(|e| EncodeTraceError(i, e))?; + } + */ + for (i, entry) in relocated_trace.iter().enumerate() { + dest.write(&((entry.ap as u64).to_le_bytes())) + .map_err(|e| EncodeTraceError(i, e))?; + dest.write(&((entry.fp as u64).to_le_bytes())) + .map_err(|e| EncodeTraceError(i, e))?; + dest.write(&((entry.pc as u64).to_le_bytes())) + .map_err(|e| EncodeTraceError(i, e))?; } - buffer.flush() + Ok(()) } -/* - Writes a binary memory file with the relocated memory as input. - The memory pairs (address, value) are encoded and concatenated in the file - given by the path `memory_file`. - - * address -> 8-byte encoded - * value -> 32-byte encoded -*/ -pub fn write_binary_memory( +/// Writes a binary representation of the relocated memory. +/// +/// The memory pairs (address, value) are encoded and concatenated: +/// * address -> 8-byte encoded +/// * value -> 32-byte encoded +pub fn write_encoded_memory( relocated_memory: &[Option], - memory_file: &Path, -) -> io::Result<()> { - let file = File::create(memory_file)?; - let mut buffer = BufWriter::new(file); - + dest: &mut impl Writer, +) -> Result<(), EncodeTraceError> { // initialize bytes vector that will be dumped to file - let mut memory_bytes: Vec = Vec::new(); + /* + let mut serialized: [u8; 40] = [0; 40]; for (i, memory_cell) in relocated_memory.iter().enumerate() { match memory_cell { None => continue, Some(unwrapped_memory_cell) => { - encode_relocated_memory(&mut memory_bytes, i, unwrapped_memory_cell); + serialized[..8].copy_from_slice(&(i as u64).to_le_bytes()); + serialized[8..].copy_from_slice(&unwrapped_memory_cell.to_le_bytes()); + dest.write(&serialized) + .map_err(|e| EncodeTraceError(i, e))?; + } + } + } + */ + for (i, memory_cell) in relocated_memory.iter().enumerate() { + match memory_cell { + None => continue, + Some(unwrapped_memory_cell) => { + dest.write(&(i as u64).to_le_bytes()) + .map_err(|e| EncodeTraceError(i, e))?; + dest.write(&unwrapped_memory_cell.to_le_bytes()) + .map_err(|e| EncodeTraceError(i, e))?; } } } - buffer.write_all(&memory_bytes)?; - buffer.flush() -} - -// encodes a given memory cell. -fn encode_relocated_memory(memory_bytes: &mut Vec, addr: usize, memory_cell: &Felt) { - // append memory address to bytes vector using a 8 bytes representation - let mut addr_bytes = (addr as u64).to_le_bytes().to_vec(); - memory_bytes.append(&mut addr_bytes); - - // append memory value at address using a 32 bytes representation - let mut value_bytes = memory_cell.to_signed_bytes_le(); - value_bytes.resize(32, 0); - memory_bytes.append(&mut value_bytes); + Ok(()) } #[cfg(test)] mod tests { use super::*; + use crate::stdlib::prelude::*; use crate::{ hint_processor::{ builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -171,15 +160,17 @@ mod tests { }, utils::test_utils::*, }; - use std::io::Read; + use bincode::enc::write::SliceWriter; + use felt::Felt; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; fn run_test_program( - program_path: &Path, + program_content: &[u8], hint_processor: &mut dyn HintProcessor, ) -> Result<(CairoRunner, VirtualMachine), CairoRunError> { - let program = - Program::from_file(program_path, Some("main")).map_err(CairoRunError::Program)?; - + let program = Program::from_bytes(program_content, Some("main")).unwrap(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(true); let end = cairo_runner @@ -194,9 +185,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_custom_entry_point() { - let program_path = Path::new("cairo_programs/not_main.json"); - let program = Program::from_file(program_path, Some("not_main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../cairo_programs/not_main.json"), + Some("not_main"), + ) + .unwrap(); let mut vm = vm!(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); @@ -211,72 +206,65 @@ mod tests { assert_eq!(cairo_runner.relocated_memory[2], Some(Felt::new(123))); } - fn compare_files(file_path_1: &Path, file_path_2: &Path) -> io::Result<()> { - let mut file_1 = File::open(file_path_1)?; - let mut file_2 = File::open(file_path_2)?; - - let mut buffer_1 = Vec::new(); - let mut buffer_2 = Vec::new(); - - file_1.read_to_end(&mut buffer_1)?; - file_2.read_to_end(&mut buffer_2)?; - - assert_eq!(&buffer_1.len(), &buffer_2.len()); - - for (buf_byte_1, buf_byte_2) in buffer_1.iter().zip(buffer_2.iter()) { - assert_eq!(buf_byte_1, buf_byte_2); - } - Ok(()) - } - #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_no_data_program() { // a compiled program with no `data` key. // it should fail when the program is loaded. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let no_data_program_path = Path::new("cairo_programs/no_data_program.json"); + let no_data_program_path = + include_bytes!("../cairo_programs/manually_compiled/no_data_program.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(no_data_program_path, &cairo_run_config, &mut hint_processor).is_err()); + assert!(cairo_run(no_data_program_path, &cairo_run_config, &mut hint_processor,).is_err()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_no_main_program() { // a compiled program with no main scope // it should fail when trying to run initialize_main_entrypoint. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let no_main_program_path = Path::new("cairo_programs/no_main_program.json"); + let no_main_program = + include_bytes!("../cairo_programs/manually_compiled/no_main_program.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(no_main_program_path, &cairo_run_config, &mut hint_processor).is_err()); + assert!(cairo_run(no_main_program, &cairo_run_config, &mut hint_processor,).is_err()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_with_invalid_memory() { // the program invalid_memory.json has an invalid memory cell and errors when trying to // decode the instruction. let mut hint_processor = BuiltinHintProcessor::new_empty(); - let invalid_memory = Path::new("cairo_programs/invalid_memory.json"); + let invalid_memory = + include_bytes!("../cairo_programs/manually_compiled/invalid_memory.json"); let cairo_run_config = CairoRunConfig::default(); - assert!(cairo_run(invalid_memory, &cairo_run_config, &mut hint_processor).is_err()); + assert!(cairo_run(invalid_memory, &cairo_run_config, &mut hint_processor,).is_err()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_output_program() { - let program_path = Path::new("cairo_programs/bitwise_output.json"); + let program_content = include_bytes!("../cairo_programs/bitwise_output.json"); let mut hint_processor = BuiltinHintProcessor::new_empty(); - let (mut cairo_runner, mut vm) = run_test_program(program_path, &mut hint_processor) + let (_, mut vm) = run_test_program(program_content, &mut hint_processor) .expect("Couldn't initialize cairo runner"); - assert!(write_output(&mut cairo_runner, &mut vm).is_ok()); + + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "0\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_binary_trace_file() { - let program_path = Path::new("cairo_programs/struct.json"); - let expected_trace_path = Path::new("cairo_programs/trace_memory/cairo_trace_struct"); - let cairo_rs_trace_path = Path::new("cairo_programs/trace_memory/struct_cairo_rs.trace"); + let program_content = include_bytes!("../cairo_programs/struct.json"); + let expected_encoded_trace = + include_bytes!("../cairo_programs/trace_memory/cairo_trace_struct"); // run test program until the end let mut hint_processor = BuiltinHintProcessor::new_empty(); - let cairo_runner_result = run_test_program(program_path, &mut hint_processor); + let cairo_runner_result = run_test_program(program_content, &mut hint_processor); let (mut cairo_runner, mut vm) = cairo_runner_result.unwrap(); // relocate memory so we can dump it to file @@ -284,40 +272,49 @@ mod tests { assert!(vm.trace.is_some()); assert!(cairo_runner.relocated_trace.is_some()); + let trace_entries = cairo_runner.relocated_trace.unwrap(); + let mut buffer = [0; 24]; + let mut buff_writer = SliceWriter::new(&mut buffer); // write cairo_rs vm trace file - assert!( - write_binary_trace(&cairo_runner.relocated_trace.unwrap(), cairo_rs_trace_path).is_ok() - ); + write_encoded_trace(&trace_entries, &mut buff_writer).unwrap(); // compare that the original cairo vm trace file and cairo_rs vm trace files are equal - assert!(compare_files(cairo_rs_trace_path, expected_trace_path).is_ok()); + assert_eq!(buffer, *expected_encoded_trace); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_binary_memory_file() { - let program_path = Path::new("cairo_programs/struct.json"); - let expected_memory_path = Path::new("cairo_programs/trace_memory/cairo_memory_struct"); - let cairo_rs_memory_path = Path::new("cairo_programs/trace_memory/struct_cairo_rs.memory"); + let program_content = include_bytes!("../cairo_programs/struct.json"); + let expected_encoded_memory = + include_bytes!("../cairo_programs/trace_memory/cairo_memory_struct"); // run test program until the end let mut hint_processor = BuiltinHintProcessor::new_empty(); - let cairo_runner_result = run_test_program(program_path, &mut hint_processor); + let cairo_runner_result = run_test_program(program_content, &mut hint_processor); let (mut cairo_runner, mut vm) = cairo_runner_result.unwrap(); // relocate memory so we can dump it to file assert!(cairo_runner.relocate(&mut vm).is_ok()); + let mut buffer = [0; 120]; + let mut buff_writer = SliceWriter::new(&mut buffer); // write cairo_rs vm memory file - assert!(write_binary_memory(&cairo_runner.relocated_memory, cairo_rs_memory_path).is_ok()); + write_encoded_memory(&cairo_runner.relocated_memory, &mut buff_writer).unwrap(); // compare that the original cairo vm memory file and cairo_rs vm memory files are equal - assert!(compare_files(cairo_rs_memory_path, expected_memory_path).is_ok()); + assert_eq!(*expected_encoded_memory, buffer); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_with_no_trace() { - let program_path = Path::new("cairo_programs/struct.json"); - let program = Program::from_file(program_path, Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../cairo_programs/struct.json"), + Some("main"), + ) + .unwrap(); + let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/blake2s_hash.rs b/src/hint_processor/builtin_hint_processor/blake2s_hash.rs index 808d50f5c8..53515fd969 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_hash.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_hash.rs @@ -1,4 +1,4 @@ -use std::ops::Shl; +use crate::stdlib::{ops::Shl, prelude::*}; pub const IV: [u32; 8] = [ 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19, @@ -131,7 +131,11 @@ pub fn blake2s_compress( mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_a() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -151,6 +155,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_b() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -170,6 +175,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_c() { //Hashing "Hello World" let h: [u32; 8] = [ @@ -192,6 +198,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_d() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -214,6 +221,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_e() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -236,6 +244,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_f() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, @@ -258,6 +267,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_compress_test_g() { let h: [u32; 8] = [ 1795745351, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, diff --git a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs index 7723b41d05..62a6528e85 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -13,7 +15,6 @@ use crate::{ }; use felt::Felt; use num_traits::ToPrimitive; -use std::{borrow::Cow, collections::HashMap}; fn get_fixed_size_u32_array( h_range: &Vec>, @@ -221,9 +222,12 @@ mod tests { vm::{errors::memory_errors::MemoryError, vm_memory::memory::Memory}, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_offset_zero() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -245,6 +249,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_empty_segment() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -266,6 +271,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_not_relocatable() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -285,6 +291,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_input_bigger_than_u32() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -313,6 +320,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_blake2s_output_input_relocatable() { let hint_code = "from starkware.cairo.common.cairo_blake2s.blake2s_utils import compute_blake2s_func\ncompute_blake2s_func(segments=segments, output_ptr=ids.output)"; //Create vm @@ -333,6 +341,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_valid() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -379,6 +388,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_invalid_segment_taken() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -404,6 +414,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_blake2s_invalid_no_ids() { let hint_code = "# Add dummy pairs of input and output.\nfrom starkware.cairo.common.cairo_blake2s.blake2s_utils import IV, blake2s_compress\n\n_n_packed_instances = int(ids.N_PACKED_INSTANCES)\nassert 0 <= _n_packed_instances < 20\n_blake2s_input_chunk_size_felts = int(ids.INPUT_BLOCK_FELTS)\nassert 0 <= _blake2s_input_chunk_size_felts < 100\n\nmessage = [0] * _blake2s_input_chunk_size_felts\nmodified_iv = [IV[0] ^ 0x01010020] + IV[1:]\noutput = blake2s_compress(\n message=message,\n h=modified_iv,\n t0=0,\n t1=0,\n f0=0xffffffff,\n f1=0,\n)\npadding = (modified_iv + message + [0, 0xffffffff] + output) * (_n_packed_instances - 1)\nsegments.write_arg(ids.blake2s_ptr_end, padding)"; //Create vm @@ -418,6 +429,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_valid_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.low >> (B * i)) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.high >> (B * i)) & MASK for i in range(4)]"; //Create vm @@ -450,6 +462,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_valid_non_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.low >> (B * i)) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.high >> (B * i)) & MASK for i in range(4)]"; //Create vm @@ -482,6 +495,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_bigend_valid_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.high >> (B * (3 - i))) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.low >> (B * (3 - i))) & MASK for i in range(4)])"; //Create vm @@ -514,6 +528,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn blake2s_add_uint256_bigend_valid_non_zero() { let hint_code = "B = 32\nMASK = 2 ** 32 - 1\nsegments.write_arg(ids.data, [(ids.high >> (B * (3 - i))) & MASK for i in range(4)])\nsegments.write_arg(ids.data + 4, [(ids.low >> (B * (3 - i))) & MASK for i in range(4)])"; //Create vm diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index db4dd67767..6f94342a24 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, collections::HashMap, prelude::*, rc::Rc}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -60,7 +62,6 @@ use crate::{ vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; use felt::Felt; -use std::{any::Any, collections::HashMap, rc::Rc}; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; @@ -447,6 +448,7 @@ impl HintProcessor for BuiltinHintProcessor { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::any::Any; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -461,9 +463,12 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::{One, Zero}; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_empty_memory() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -477,6 +482,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_preset_memory() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -492,6 +498,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_alloc_hint_ap_is_not_empty() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -516,6 +523,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unknown_hint() { let hint_code = "random_invalid_code"; let mut vm = vm!(); @@ -526,6 +534,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_enter_scope_valid() { let hint_code = "vm_enter_scope({'n': ids.len})"; let mut vm = vm!(); @@ -540,6 +549,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_enter_scope_invalid() { let hint_code = "vm_enter_scope({'n': ids.len})"; let mut vm = vm!(); @@ -560,6 +570,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_valid() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -577,6 +588,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_variable_not_in_scope_error() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -595,6 +607,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memcpy_continue_copying_insert_error() { let hint_code = "n -= 1\nids.continue_copying = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -624,6 +637,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_valid() { let hint_code = "vm_exit_scope()"; let mut vm = vm!(); @@ -637,6 +651,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_invalid() { let hint_code = "vm_exit_scope()"; let mut vm = vm!(); @@ -652,6 +667,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_enter_scope() { let hint_code = "vm_enter_scope()"; //Create vm @@ -669,6 +685,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_valid() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -691,6 +708,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_max_size() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -715,6 +733,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_invalid_input_length() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -736,6 +755,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_invalid_word_size() { let hint_code = "from eth_hash.auto import keccak\n\ndata, length = ids.data, ids.length\n\nif '__keccak_max_size' in globals():\n assert length <= __keccak_max_size, \\\n f'unsafe_keccak() can only be used with length<={__keccak_max_size}. ' \\\n f'Got: length={length}.'\n\nkeccak_input = bytearray()\nfor word_i, byte_i in enumerate(range(0, length, 16)):\n word = memory[data + word_i]\n n_bytes = min(16, length - byte_i)\n assert 0 <= word < 2 ** (8 * n_bytes)\n keccak_input += word.to_bytes(n_bytes, 'big')\n\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -761,6 +781,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_valid() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -781,6 +802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_nones_in_range() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -803,6 +825,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsafe_keccak_finalize_expected_integer_at_range() { let hint_code = "from eth_hash.auto import keccak\nkeccak_input = bytearray()\nn_elms = ids.keccak_state.end_ptr - ids.keccak_state.start_ptr\nfor word in memory.get_range(ids.keccak_state.start_ptr, n_elms):\n keccak_input += word.to_bytes(16, 'big')\nhashed = keccak(keccak_input)\nids.high = int.from_bytes(hashed[:16], 'big')\nids.low = int.from_bytes(hashed[16:32], 'big')"; let mut vm = vm!(); @@ -834,6 +857,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_hint_add_same_hint_twice() { let mut hint_processor = BuiltinHintProcessor::new_empty(); let hint_func = Rc::new(HintFunc(Box::new(enter_scope))); diff --git a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs index a6a0646f7e..b9cd8c0142 100644 --- a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs +++ b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs @@ -1,3 +1,8 @@ +use crate::stdlib::{ + borrow::{Cow, ToOwned}, + collections::HashMap, + prelude::*, +}; use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -14,7 +19,6 @@ use crate::{ }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; -use std::{borrow::Cow, collections::HashMap}; // Constants in package "starkware.cairo.common.cairo_keccak.keccak". const BYTES_IN_WORD: &str = "starkware.cairo.common.cairo_keccak.keccak.BYTES_IN_WORD"; @@ -252,6 +256,7 @@ pub fn u64_array_to_mayberelocatable_vec(array: &[u64]) -> Vec #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -269,9 +274,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn keccak_write_args_valid_test() { let hint_code = "segments.write_arg(ids.inputs, [ids.low % 2 ** 64, ids.low // 2 ** 64])\nsegments.write_arg(ids.inputs + 2, [ids.high % 2 ** 64, ids.high // 2 ** 64])"; let mut vm = vm_with_range_check!(); @@ -289,6 +297,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn keccak_write_args_write_error() { let hint_code = "segments.write_arg(ids.inputs, [ids.low % 2 ** 64, ids.low // 2 ** 64])\nsegments.write_arg(ids.inputs + 2, [ids.high % 2 ** 64, ids.high // 2 ** 64])"; let mut vm = vm_with_range_check!(); @@ -302,6 +311,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compare_bytes_in_word_nondet_valid() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; @@ -328,6 +338,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compare_keccak_full_rate_in_bytes_nondet_valid() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; @@ -356,6 +367,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn block_permutation_valid_test() { let hint_code = "memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"; diff --git a/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs b/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs index ab222d1ecf..3767fce2ff 100644 --- a/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs @@ -1,8 +1,9 @@ +use crate::stdlib::{any::Any, cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; + use crate::{ types::{exec_scope::ExecutionScopes, relocatable::MaybeRelocatable}, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; use crate::{ any_box, @@ -257,6 +258,7 @@ mod tests { use crate::hint_processor::builtin_hint_processor::dict_manager::Dictionary; use crate::hint_processor::builtin_hint_processor::hint_code; use crate::hint_processor::hint_processor_definition::HintProcessor; + use crate::stdlib::collections::HashMap; use crate::types::exec_scope::ExecutionScopes; use crate::vm::vm_memory::memory::Memory; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; @@ -268,9 +270,12 @@ mod tests { vm::{errors::memory_errors::MemoryError, vm_core::VirtualMachine}, }; use assert_matches::assert_matches; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_with_initial_dict_empty() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -302,6 +307,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_with_no_initial_dict() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -313,6 +319,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_new_ap_is_taken() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_dict(segments, initial_dict)\ndel initial_dict"; let mut vm = vm!(); @@ -337,6 +344,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_valid() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -364,6 +372,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_invalid_key() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -381,6 +390,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_read_no_tracker() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"; let mut vm = vm!(); @@ -401,6 +411,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_default_dict_new_valid() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_default_dict(segments, ids.default_value)"; let mut vm = vm!(); @@ -432,6 +443,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_default_dict_new_no_default_value() { let hint_code = "if '__dict_manager' not in globals():\n from starkware.cairo.common.dict import DictManager\n __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_default_dict(segments, ids.default_value)"; let mut vm = vm!(); @@ -445,6 +457,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_default_valid_empty_dict() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -472,6 +485,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_default_valid_overwrite_value() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -499,6 +513,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_simple_valid_overwrite_value() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -527,6 +542,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_simple_valid_cant_write_new_key() { let hint_code = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"; let mut vm = vm!(); @@ -551,6 +567,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_valid() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -575,6 +592,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_valid_no_change() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -599,6 +617,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_invalid_wrong_prev_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -628,6 +647,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_simple_invalid_wrong_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -651,6 +671,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -675,6 +696,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid_no_change() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -699,6 +721,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_invalid_wrong_prev_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -728,6 +751,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_invalid_wrong_key() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -757,6 +781,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_update_default_valid_no_key_prev_value_equals_default() { let hint_code = "# Verify dict pointer and prev value.\ndict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ncurrent_value = dict_tracker.data[ids.key]\nassert current_value == ids.prev_value, \\\n f'Wrong previous value in dict. Got {ids.prev_value}, expected {current_value}.'\n\n# Update value.\ndict_tracker.data[ids.key] = ids.new_value\ndict_tracker.current_ptr += ids.DictAccess.SIZE"; let mut vm = vm!(); @@ -781,6 +806,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_valid_empty_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -809,6 +835,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_valid_non_empty_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -840,6 +867,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_copy_dict_invalid_no_dict() { let hint_code = "# Prepare arguments for dict_new. In particular, the same dictionary values should be copied\n# to the new (squashed) dictionary.\nvm_enter_scope({\n # Make __dict_manager accessible.\n '__dict_manager': __dict_manager,\n # Create a copy of the dict, in case it changes in the future.\n 'initial_dict': dict(__dict_manager.get_dict(ids.dict_accesses_end)),\n})"; let mut vm = vm!(); @@ -860,6 +888,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_no_tracker() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -880,6 +909,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_valid() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -899,6 +929,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_squash_update_ptr_mismatched_dict_ptr() { let hint_code = "# Update the DictTracker's current_ptr to point to the end of the squashed dict.\n__dict_manager.get_tracker(ids.squashed_dict_start).current_ptr = \\\n ids.squashed_dict_end.address_"; let mut vm = vm!(); @@ -921,6 +952,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_dict_write_valid_relocatable_new_value() { let mut vm = vm!(); //Initialize fp diff --git a/src/hint_processor/builtin_hint_processor/dict_manager.rs b/src/hint_processor/builtin_hint_processor/dict_manager.rs index 5d1b1ff5a9..28102ac887 100644 --- a/src/hint_processor/builtin_hint_processor/dict_manager.rs +++ b/src/hint_processor/builtin_hint_processor/dict_manager.rs @@ -1,4 +1,4 @@ -use std::collections::HashMap; +use crate::stdlib::collections::HashMap; use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, @@ -202,13 +202,18 @@ mod tests { use crate::{relocatable, utils::test_utils::*, vm::vm_core::VirtualMachine}; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_manager() { let dict_manager = DictManager::new(); assert_eq!(dict_manager.trackers, HashMap::new()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_tracker_empty() { let dict_tracker = DictTracker::new_empty(relocatable!(1, 0)); assert_eq!( @@ -219,6 +224,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_dict_tracker_default() { let dict_tracker = DictTracker::new_default_dict(relocatable!(1, 0), &MaybeRelocatable::from(5), None); @@ -233,6 +239,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_empty() { let mut vm = vm!(); let mut dict_manager = DictManager::new(); @@ -247,6 +254,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_default() { let mut dict_manager = DictManager::new(); let mut vm = vm!(); @@ -265,6 +273,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_with_initial_dict() { let mut dict_manager = DictManager::new(); let mut vm = vm!(); @@ -284,6 +293,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_default_dict_with_initial_dict() { let mut dict_manager = DictManager::new(); let mut initial_dict = HashMap::::new(); @@ -308,6 +318,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_dict_empty_same_segment() { let mut dict_manager = DictManager::new(); dict_manager @@ -321,6 +332,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_new_default_dict_empty_same_segment() { let mut dict_manager = DictManager::new(); dict_manager.trackers.insert( @@ -335,6 +347,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dictionary_get_insert_simple() { let mut dictionary = Dictionary::SimpleDictionary(HashMap::new()); dictionary.insert(&MaybeRelocatable::from(1), &MaybeRelocatable::from(2)); @@ -346,6 +359,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dictionary_get_insert_default() { let mut dictionary = Dictionary::DefaultDictionary { dict: HashMap::new(), diff --git a/src/hint_processor/builtin_hint_processor/find_element_hint.rs b/src/hint_processor/builtin_hint_processor/find_element_hint.rs index 1e559fa252..cd0b013b3a 100644 --- a/src/hint_processor/builtin_hint_processor/find_element_hint.rs +++ b/src/hint_processor/builtin_hint_processor/find_element_hint.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -13,7 +15,6 @@ use crate::{ }; use felt::Felt; use num_traits::{Signed, ToPrimitive}; -use std::collections::HashMap; pub fn find_element( vm: &mut VirtualMachine, @@ -132,6 +133,7 @@ pub fn search_sorted_lower( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::{ any_box, hint_processor::{ @@ -147,7 +149,9 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::{One, Zero}; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; fn init_vm_ids_data( values_to_override: HashMap, @@ -217,16 +221,15 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_found_by_search() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); - assert_matches!( - run_hint!(vm, ids_data, hint_code::FIND_ELEMENT.to_string()), - Ok(()) - ); + assert_matches!(run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), Ok(())); check_memory![vm.segments.memory, ((1, 3), 1)]; } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_found_by_oracle() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_index", Felt::one())]; @@ -238,6 +241,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_not_found_search() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "key".to_string(), @@ -250,6 +254,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_not_found_oracle() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_index", Felt::new(2))]; @@ -260,6 +265,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_failed_ids_get_from_mem() { let mut vm = vm!(); vm.run_context.fp = 5; @@ -272,6 +278,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_not_int_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -285,6 +292,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_zero_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -297,6 +305,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_negative_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -309,6 +318,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_not_int_n_elms() { let relocatable = MaybeRelocatable::from((1, 2)); let (mut vm, ids_data) = @@ -321,6 +331,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_negative_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -333,12 +344,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_empty_scope() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!(run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), Ok(())); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_n_elms_gt_max_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_max_size", Felt::one())]; @@ -349,6 +362,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_key_not_int() { let relocatable = MaybeRelocatable::from((1, 4)); let (mut vm, ids_data) = @@ -360,6 +374,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!( @@ -371,6 +386,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_no_matches() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "key".to_string(), @@ -384,6 +400,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_not_int_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -397,6 +414,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_zero_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -409,6 +427,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_negative_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), @@ -421,6 +440,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_not_int_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -434,6 +454,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_negative_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), @@ -446,6 +467,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_empty_scope() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); assert_matches!( @@ -455,6 +477,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_n_elms_gt_max_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); let mut exec_scopes = scope![("find_element_max_size", Felt::one())]; diff --git a/src/hint_processor/builtin_hint_processor/hint_utils.rs b/src/hint_processor/builtin_hint_processor/hint_utils.rs index eb31045b2a..796ebe2911 100644 --- a/src/hint_processor/builtin_hint_processor/hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/hint_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; + use felt::Felt; use crate::hint_processor::hint_processor_definition::HintReference; @@ -12,8 +14,6 @@ use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; use crate::vm::errors::hint_errors::HintError; use crate::vm::vm_core::VirtualMachine; -use std::borrow::Cow; -use std::collections::HashMap; //Inserts value into the address of the given ids variable pub fn insert_value_from_var_name( @@ -122,6 +122,7 @@ pub fn get_reference_from_var_name<'a>( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ hint_processor::hint_processor_definition::HintReference, @@ -134,7 +135,11 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_immediate_value() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -149,6 +154,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -162,6 +168,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_var_name_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); @@ -175,6 +182,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -188,6 +196,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_var_name_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -202,6 +211,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -215,6 +225,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_from_var_name_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); @@ -228,6 +239,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 1)]; @@ -241,6 +253,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 38a5bb348c..af2c259fdf 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{cmp, collections::HashMap, ops::Shl, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -12,7 +14,6 @@ use crate::{ use felt::Felt; use num_traits::{One, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; -use std::{cmp, collections::HashMap, ops::Shl}; /* Implements hint: %{ diff --git a/src/hint_processor/builtin_hint_processor/math_utils.rs b/src/hint_processor/builtin_hint_processor/math_utils.rs index f99246b10e..8a12232418 100644 --- a/src/hint_processor/builtin_hint_processor/math_utils.rs +++ b/src/hint_processor/builtin_hint_processor/math_utils.rs @@ -1,4 +1,11 @@ +use crate::stdlib::{ + collections::HashMap, + ops::{Shl, Shr}, + prelude::*, +}; + use crate::utils::CAIRO_PRIME; + use crate::{ any_box, hint_processor::{ @@ -21,11 +28,6 @@ use num_bigint::BigUint; use num_integer::Integer; use num_traits::One; use num_traits::{Signed, Zero}; -use std::{ - any::Any, - collections::HashMap, - ops::{Shl, Shr}, -}; use super::hint_utils::get_maybe_relocatable_from_var_name; @@ -536,6 +538,7 @@ fn div_prime_by_bound(bound: Felt) -> Result { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::ops::Shl; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -556,9 +559,12 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::Zero; - use std::{any::Any, ops::Shl}; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_false() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -576,6 +582,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_true() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -593,6 +600,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] //This test contemplates the case when the number itself is negative, but it is within the range (-prime, -range_check_bound) //Making the comparison return 1 (true) fn run_is_nn_hint_true_border_case() { @@ -617,6 +625,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_no_range_check_builtin() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm!(); @@ -636,6 +645,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_incorrect_ids() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -651,6 +661,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_cant_get_ids_from_memory() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -669,6 +680,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_ids_are_relocatable_values() { let hint_code = "memory[ap] = 0 if 0 <= (ids.a % PRIME) < range_check_builtin.bound else 1"; let mut vm = vm_with_range_check!(); @@ -687,6 +699,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_le_felt_valid() { let hint_code = ASSERT_LE_FELT; let mut constants = HashMap::new(); @@ -716,6 +729,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_le_felt_hint_true() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm_with_range_check!(); @@ -732,6 +746,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_le_felt_hint_inconsistent_memory() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm_with_range_check!(); @@ -756,6 +771,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_le_felt_hint_incorrect_ids() { let hint_code = "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1"; let mut vm = vm!(); @@ -770,6 +786,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_valid() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -785,6 +802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_invalid() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -802,6 +820,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -818,6 +837,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_a_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -835,6 +855,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm!(); @@ -853,6 +874,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_nn_reference_is_not_in_memory() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'"; let mut vm = vm_with_range_check!(); @@ -869,6 +891,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_invalid() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -896,6 +919,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_a_is_not_integer() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -923,6 +947,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_assert_le_felt_b_is_not_integer() { let hint_code = ASSERT_LE_FELT; let mut vm = vm_with_range_check!(); @@ -950,6 +975,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_out_of_range_false() { let hint_code = "memory[ap] = 0 if 0 <= ((-ids.a - 1) % PRIME) < range_check_builtin.bound else 1"; @@ -967,6 +993,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_nn_hint_out_of_range_true() { let hint_code = "memory[ap] = 0 if 0 <= ((-ids.a - 1) % PRIME) < range_check_builtin.bound else 1"; @@ -983,6 +1010,7 @@ mod tests { check_memory![vm.segments.memory, ((1, 0), 0)]; } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_false() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1003,6 +1031,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1016,6 +1045,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_int_bignum_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1039,6 +1069,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_false() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1059,6 +1090,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_true() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1072,6 +1104,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_non_equal_relocatable_diff_index() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1091,6 +1124,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_equal_relocatable_and_integer() { let hint_code = "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"; let mut vm = vm!(); @@ -1112,6 +1146,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_true() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1127,6 +1162,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_false() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1147,6 +1183,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_incorrect_id() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1164,6 +1201,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_not_zero_expected_integer_error() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'"; @@ -1182,6 +1220,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_assertion_invalid() { let hint_code = "assert ids.value == 0, 'split_int(): value is out of range.'"; let mut vm = vm!(); @@ -1198,6 +1237,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_assertion_valid() { let hint_code = "assert ids.value == 0, 'split_int(): value is out of range.'"; let mut vm = vm!(); @@ -1211,6 +1251,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_valid() { let hint_code = "memory[ids.output] = res = (int(ids.value) % PRIME) % ids.base\nassert res < ids.bound, f'split_int(): Limb {res} is out of range.'"; let mut vm = vm!(); @@ -1226,6 +1267,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_int_invalid() { let hint_code = "memory[ids.output] = res = (int(ids.value) % PRIME) % ids.base\nassert res < ids.bound, f'split_int(): Limb {res} is out of range.'"; let mut vm = vm!(); @@ -1248,6 +1290,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_true() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1266,6 +1309,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_false() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1283,6 +1327,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_outside_valid_range() { let hint_code = "from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; @@ -1309,6 +1354,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_positive_hint_is_positive_not_empty() { let hint_code ="from starkware.cairo.common.math_utils import is_positive\nids.is_positive = 1 if is_positive(\n value=ids.value, prime=PRIME, rc_bound=range_check_builtin.bound) else 0"; let mut vm = vm_with_range_check!(); @@ -1334,6 +1380,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_valid() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1350,6 +1397,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_invalid_negative_number() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1369,6 +1417,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_sqrt_invalid_mismatched_root() { let hint_code = "from starkware.python.math_utils import isqrt\nvalue = ids.value % PRIME\nassert value < 2 ** 250, f\"value={value} is outside of the range [0, 2**250).\"\nassert 2 ** 250 < PRIME\nids.root = isqrt(value)"; let mut vm = vm!(); @@ -1394,6 +1443,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_success() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1409,6 +1459,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_out_of_range() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1429,6 +1480,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm!(); @@ -1447,6 +1499,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_inconsitent_memory() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1472,6 +1525,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn unsigned_div_rem_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"; let mut vm = vm_with_range_check!(); @@ -1489,6 +1543,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_success() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1504,6 +1559,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_negative_quotient() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1519,6 +1575,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_out_of_range() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1539,6 +1596,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_no_range_check_builtin() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm!(); @@ -1557,6 +1615,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_inconsitent_memory() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1582,6 +1641,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn signed_div_rem_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import as_int, assert_integer\n\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n f'div={hex(ids.div)} is out of the valid range.'\n\nassert_integer(ids.bound)\nassert ids.bound <= range_check_builtin.bound // 2, \\\n f'bound={hex(ids.bound)} is out of the valid range.'\n\nint_value = as_int(ids.value, PRIME)\nq, ids.r = divmod(int_value, ids.div)\n\nassert -ids.bound <= q < ids.bound, \\\n f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'\n\nids.biased_q = q + ids.bound"; let mut vm = vm_with_range_check!(); @@ -1599,6 +1659,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_250_bit_valid() { let hint_code = "from starkware.cairo.common.math_utils import as_int\n\n# Correctness check.\nvalue = as_int(ids.value, PRIME) % PRIME\nassert value < ids.UPPER_BOUND, f'{value} is outside of the range [0, 2**250).'\n\n# Calculation for the assertion.\nids.high, ids.low = divmod(ids.value, ids.SHIFT)"; let mut vm = vm!(); @@ -1616,6 +1677,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_250_bit_invalid() { let hint_code = "from starkware.cairo.common.math_utils import as_int\n\n# Correctness check.\nvalue = as_int(ids.value, PRIME) % PRIME\nassert value < ids.UPPER_BOUND, f'{value} is outside of the range [0, 2**250).'\n\n# Calculation for the assertion.\nids.high, ids.low = divmod(ids.value, ids.SHIFT)"; let mut vm = vm!(); @@ -1640,6 +1702,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_ok() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1668,6 +1731,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1689,6 +1753,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_fails_first_insert() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1723,6 +1788,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_fails_second_insert() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1757,6 +1823,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_felt_value_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert ids.MAX_HIGH < 2**128 and ids.MAX_LOW < 2**128\nassert PRIME - 1 == ids.MAX_HIGH * 2**128 + ids.MAX_LOW\nassert_integer(ids.value)\nids.low = ids.value & ((1 << 128) - 1)\nids.high = ids.value >> 128"; @@ -1779,6 +1846,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_ok() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1794,6 +1862,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_assert_fails() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1810,6 +1879,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_incorrect_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1827,6 +1897,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_a_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1844,6 +1915,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_b_is_not_integer() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; @@ -1861,6 +1933,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_assert_lt_felt_ok_failed_to_get_ids() { let hint_code = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'"; diff --git a/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs b/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs index a7e8d36ad6..4ac912179b 100644 --- a/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -11,7 +13,6 @@ use crate::{ }; use felt::Felt; use num_traits::{One, Zero}; -use std::{any::Any, collections::HashMap}; //Implements hint: memory[ap] = segments.add() pub fn add_segment(vm: &mut VirtualMachine) -> Result<(), HintError> { @@ -82,7 +83,11 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_valid() { let mut vm = vm!(); // initialize memory segments @@ -108,6 +113,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_var_name_invalid_expected_integer() { let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/memset_utils.rs b/src/hint_processor/builtin_hint_processor/memset_utils.rs index 8d13dd38da..f915c544f2 100644 --- a/src/hint_processor/builtin_hint_processor/memset_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memset_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -11,7 +13,6 @@ use crate::{ }; use felt::Felt; use num_traits::Signed; -use std::{any::Any, collections::HashMap}; // Implements hint: // %{ vm_enter_scope({'n': ids.n}) %} @@ -56,6 +57,7 @@ pub fn memset_continue_loop( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -72,7 +74,11 @@ mod tests { use assert_matches::assert_matches; use num_traits::{One, Zero}; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_enter_scope_valid() { let hint_code = "vm_enter_scope({'n': ids.n})"; let mut vm = vm!(); @@ -85,6 +91,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_enter_scope_invalid() { let hint_code = "vm_enter_scope({'n': ids.n})"; let mut vm = vm!(); @@ -102,6 +109,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_valid_continue_loop_equal_1() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -119,6 +127,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_valid_continue_loop_equal_5() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -137,6 +146,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_variable_not_in_scope_error() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); @@ -158,6 +168,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memset_continue_loop_insert_error() { let hint_code = "n -= 1\nids.continue_loop = 1 if n > 0 else 0"; let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/pow_utils.rs b/src/hint_processor/builtin_hint_processor/pow_utils.rs index 6de8b9e877..7986ac277b 100644 --- a/src/hint_processor/builtin_hint_processor/pow_utils.rs +++ b/src/hint_processor/builtin_hint_processor/pow_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -10,7 +12,6 @@ use crate::{ }; use felt::Felt; use num_integer::Integer; -use std::collections::HashMap; /* Implements hint: @@ -53,9 +54,12 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::One; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_ok() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -69,6 +73,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_incorrect_ids() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -85,6 +90,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_incorrect_references() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -101,6 +107,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_prev_locs_exp_is_not_integer() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); @@ -119,6 +126,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_pow_invalid_memory_insert() { let hint_code = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs b/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs index 68670332bd..4c8d59772e 100644 --- a/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs @@ -1,3 +1,4 @@ +use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -14,7 +15,6 @@ use crate::{ vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; use felt::Felt; -use std::{borrow::Cow, collections::HashMap}; #[derive(Debug, PartialEq)] pub(crate) struct BigInt3<'a> { @@ -109,6 +109,8 @@ mod tests { BuiltinHintProcessor, HintProcessorData, }; use crate::hint_processor::hint_processor_definition::HintProcessor; + use crate::stdlib::ops::Shl; + use crate::stdlib::string::ToString; use crate::types::exec_scope::ExecutionScopes; use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; @@ -120,10 +122,12 @@ mod tests { use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use assert_matches::assert_matches; use num_traits::One; - use std::any::Any; - use std::ops::Shl; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); @@ -160,6 +164,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_value_not_in_scope() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); @@ -175,6 +180,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_nondet_bigint3_split_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import split\n\nsegments.write_arg(ids.res.address_, split(value))"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs b/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs index cad7bd38a1..5e2cabf9e5 100644 --- a/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs @@ -1,3 +1,8 @@ +use crate::stdlib::{ + collections::HashMap, + ops::{BitAnd, Shl}, + prelude::*, +}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -17,10 +22,6 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::{One, Zero}; -use std::{ - collections::HashMap, - ops::{BitAnd, Shl}, -}; use super::bigint_utils::BigInt3; @@ -330,6 +331,7 @@ pub fn ec_mul_inner( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -350,9 +352,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_negate_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\ny = pack(ids.point.y, PRIME) % SECP_P\n# The modulo operation in python always returns a nonnegative number.\nvalue = (-y) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -396,6 +401,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_compute_doubling_slope_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\nfrom starkware.python.math_utils import ec_double_slope\n\n# Compute the slope.\nx = pack(ids.point.x, PRIME)\ny = pack(ids.point.y, PRIME)\nvalue = slope = ec_double_slope(point=(x, y), alpha=0, p=SECP_P)"; let mut vm = vm_with_range_check!(); @@ -457,6 +463,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_compute_slope_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\nfrom starkware.python.math_utils import line_slope\n\n# Compute the slope.\nx0 = pack(ids.point0.x, PRIME)\ny0 = pack(ids.point0.y, PRIME)\nx1 = pack(ids.point1.x, PRIME)\ny1 = pack(ids.point1.y, PRIME)\nvalue = slope = line_slope(point1=(x0, y0), point2=(x1, y1), p=SECP_P)"; let mut vm = vm_with_range_check!(); @@ -528,6 +535,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_double_assign_new_x_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nslope = pack(ids.slope, PRIME)\nx = pack(ids.point.x, PRIME)\ny = pack(ids.point.y, PRIME)\n\nvalue = new_x = (pow(slope, 2, SECP_P) - 2 * x) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -611,6 +619,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_double_assign_new_y_ok() { let hint_code = "value = new_y = (slope * (x - new_x) - y) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -680,6 +689,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_fast_ec_add_assign_new_x_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nslope = pack(ids.slope, PRIME)\nx0 = pack(ids.point0.x, PRIME)\nx1 = pack(ids.point1.x, PRIME)\ny0 = pack(ids.point0.y, PRIME)\n\nvalue = new_x = (pow(slope, 2, SECP_P) - x0 - x1) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -757,6 +767,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_fast_ec_add_assign_new_y_ok() { let hint_code = "value = new_y = (slope * (x0 - new_x) - y0) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -828,6 +839,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_ec_mul_inner_ok() { let hint_code = "memory[ap] = (ids.scalar % PRIME) % 2"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs index 3fb1a80068..fea37db3ea 100644 --- a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, ops::Shl, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -15,7 +17,6 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::{One, Zero}; -use std::{collections::HashMap, ops::Shl}; use super::{bigint_utils::BigInt3, secp_utils::pack}; @@ -161,6 +162,7 @@ pub fn is_zero_assign_scope_variables( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -181,9 +183,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -221,6 +226,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -258,6 +264,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_verify_zero_invalid_memory_insert() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nq, r = divmod(pack(ids.val, PRIME), SECP_P)\nassert r == 0, f\"verify_zero: Invalid input {ids.val.d0, ids.val.d1, ids.val.d2}.\"\nids.q = q % PRIME"; let mut vm = vm_with_range_check!(); @@ -303,6 +310,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_reduce_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nvalue = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -355,6 +363,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_reduce_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nvalue = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -393,6 +402,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_pack_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nx = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -448,6 +458,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_pack_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P, pack\n\nx = pack(ids.x, PRIME) % SECP_P"; let mut vm = vm_with_range_check!(); @@ -487,6 +498,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_ok_true() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -513,6 +525,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_ok_false() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -539,6 +552,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_scope_error() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -559,6 +573,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_is_zero_nondet_invalid_memory_insert() { let hint_code = "memory[ap] = to_felt_or_relocatable(x == 0)"; let mut vm = vm_with_range_check!(); @@ -588,6 +603,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_assign_scope_variables_ok() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P\nfrom starkware.python.math_utils import div_mod\n\nvalue = x_inv = div_mod(1, x, SECP_P)"; let mut vm = vm_with_range_check!(); @@ -642,6 +658,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_assign_scope_variables_scope_error() { let hint_code = "from starkware.cairo.common.cairo_secp.secp_utils import SECP_P\nfrom starkware.python.math_utils import div_mod\n\nvalue = x_inv = div_mod(1, x, SECP_P)"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs b/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs index 7952efd40b..60b0232daf 100644 --- a/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs @@ -1,9 +1,9 @@ +use crate::stdlib::{collections::HashMap, ops::Shl, prelude::*}; + use crate::vm::errors::hint_errors::HintError; use felt::Felt; use num_traits::Zero; -use std::collections::HashMap; -use std::ops::Shl; use super::bigint_utils::BigInt3; @@ -64,16 +64,19 @@ pub(crate) fn pack(num: BigInt3) -> num_bigint::BigInt { #[cfg(test)] mod tests { - use std::borrow::Cow; - use super::*; + use crate::stdlib::{borrow::Cow, string::ToString}; use crate::utils::test_utils::*; use assert_matches::assert_matches; use felt::felt_str; use num_bigint::BigUint; use num_traits::One; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn secp_split() { let mut constants = HashMap::new(); constants.insert(BASE_86.to_string(), Felt::one() << 86_usize); @@ -144,6 +147,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn secp_pack() { let pack_1 = pack(BigInt3 { d0: Cow::Borrowed(&Felt::new(10_i32)), diff --git a/src/hint_processor/builtin_hint_processor/secp/signature.rs b/src/hint_processor/builtin_hint_processor/secp/signature.rs index 25d3375c70..8364e94c6a 100644 --- a/src/hint_processor/builtin_hint_processor/secp/signature.rs +++ b/src/hint_processor/builtin_hint_processor/secp/signature.rs @@ -1,3 +1,9 @@ +use crate::stdlib::{ + collections::HashMap, + ops::{Shl, Shr}, + prelude::*, +}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -16,10 +22,6 @@ use felt::Felt; use num_bigint::BigInt; use num_integer::Integer; use num_traits::One; -use std::{ - collections::HashMap, - ops::{Shl, Shr}, -}; use super::bigint_utils::BigInt3; @@ -148,6 +150,8 @@ pub fn get_point_from_x( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::ops::Shl; + use crate::stdlib::string::ToString; use crate::types::errors::math_errors::MathError; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ @@ -165,9 +169,12 @@ mod tests { }; use assert_matches::assert_matches; use num_traits::Zero; - use std::{any::Any, ops::Shl}; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn safe_div_ok() { let hint_code = hint_code::DIV_MOD_N_PACKED_DIVMOD; let mut vm = vm!(); @@ -200,6 +207,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn safe_div_fail() { let mut exec_scopes = scope![ ("a", BigInt::zero()), @@ -229,6 +237,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_point_from_x_ok() { let hint_code = hint_code::GET_POINT_FROM_X; let mut vm = vm!(); @@ -268,6 +277,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_point_from_x_negative_y() { let hint_code = hint_code::GET_POINT_FROM_X; let mut vm = vm!(); diff --git a/src/hint_processor/builtin_hint_processor/segments.rs b/src/hint_processor/builtin_hint_processor/segments.rs index 45a779ca26..6ca1e525ff 100644 --- a/src/hint_processor/builtin_hint_processor/segments.rs +++ b/src/hint_processor/builtin_hint_processor/segments.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::hint_processor::builtin_hint_processor::hint_utils::get_ptr_from_var_name; use crate::hint_processor::{ builtin_hint_processor::hint_utils::insert_value_from_var_name, @@ -6,7 +8,6 @@ use crate::hint_processor::{ use crate::serde::deserialize_program::ApTracking; use crate::vm::errors::hint_errors::HintError; use crate::vm::vm_core::VirtualMachine; -use std::collections::HashMap; /* Implements hint: @@ -63,9 +64,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_relocate_segment() { let hint_code = hint_code::RELOCATE_SEGMENT; //Initialize vm @@ -88,6 +92,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_temporary_array() { let hint_code = hint_code::TEMPORARY_ARRAY; //Initialize vm diff --git a/src/hint_processor/builtin_hint_processor/set.rs b/src/hint_processor/builtin_hint_processor/set.rs index 330f1435d3..79ae9984ad 100644 --- a/src/hint_processor/builtin_hint_processor/set.rs +++ b/src/hint_processor/builtin_hint_processor/set.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -11,7 +13,6 @@ use crate::{ }; use felt::Felt; use num_traits::{One, ToPrimitive, Zero}; -use std::collections::HashMap; pub fn set_add( vm: &mut VirtualMachine, @@ -86,7 +87,9 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; const HINT_CODE: &str = "assert ids.elm_size > 0\nassert ids.set_ptr <= ids.set_end_ptr\nelm_list = memory.get_range(ids.elm_ptr, ids.elm_size)\nfor i in range(0, ids.set_end_ptr - ids.set_ptr, ids.elm_size):\n if memory.get_range(ids.set_ptr + i, ids.elm_size) == elm_list:\n ids.index = i // ids.elm_size\n ids.is_elm_in_set = 1\n break\nelse:\n ids.is_elm_in_set = 0"; @@ -130,6 +133,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_add_new_elem() { let (mut vm, ids_data) = init_vm_ids_data(None, None, None, None); assert_matches!(run_hint!(vm, ids_data, HINT_CODE), Ok(())); @@ -144,6 +148,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_add_already_exists() { let (mut vm, ids_data) = init_vm_ids_data(None, None, Some(1), Some(3)); assert_matches!(run_hint!(vm, ids_data, HINT_CODE), Ok(())); @@ -151,6 +156,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn elm_size_negative() { let (mut vm, ids_data) = init_vm_ids_data(None, Some(-2), None, None); assert_matches!( @@ -160,6 +166,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn elm_size_zero() { let (mut vm, ids_data) = init_vm_ids_data(None, Some(0), None, None); assert_matches!( @@ -170,6 +177,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_ptr_gt_set_end_ptr() { let (mut vm, ids_data) = init_vm_ids_data(Some((2, 3)), None, None, None); assert_matches!( diff --git a/src/hint_processor/builtin_hint_processor/sha256_utils.rs b/src/hint_processor/builtin_hint_processor/sha256_utils.rs index ee7f92a31f..096ba782d2 100644 --- a/src/hint_processor/builtin_hint_processor/sha256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/sha256_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -14,7 +16,6 @@ use felt::Felt; use generic_array::GenericArray; use num_traits::{One, Zero}; use sha2::compress256; -use std::collections::HashMap; use crate::hint_processor::hint_processor_definition::HintReference; @@ -129,7 +130,11 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_input_one() { let mut vm = vm_with_range_check!(); vm.segments = segments![((1, 1), 7)]; @@ -141,6 +146,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_input_zero() { let mut vm = vm_with_range_check!(); vm.segments = segments![((1, 1), 3)]; @@ -152,6 +158,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sha256_ok() { let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/signature.rs b/src/hint_processor/builtin_hint_processor/signature.rs index b02011b406..9aa273bba7 100644 --- a/src/hint_processor/builtin_hint_processor/signature.rs +++ b/src/hint_processor/builtin_hint_processor/signature.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use num_integer::Integer; use crate::{ @@ -12,7 +14,6 @@ use crate::{ vm_core::VirtualMachine, }, }; -use std::collections::HashMap; pub fn verify_ecdsa_signature( vm: &mut VirtualMachine, @@ -66,9 +67,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_ecdsa_signature_valid() { let mut vm = vm!(); vm.builtin_runners = vec![( diff --git a/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs b/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs index d12193e669..c4bb1a0ebf 100644 --- a/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs +++ b/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -19,7 +21,6 @@ use crate::{ use felt::Felt; use num_integer::Integer; use num_traits::{One, ToPrimitive, Zero}; -use std::collections::HashMap; fn get_access_indices( exec_scopes: &mut ExecutionScopes, @@ -316,7 +317,9 @@ mod tests { }; use assert_matches::assert_matches; use felt::felt_str; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; //Hint code as consts const SQUASH_DICT_INNER_FIRST_ITERATION : &str = "current_access_indices = sorted(access_indices[key])[::-1]\ncurrent_access_index = current_access_indices.pop()\nmemory[ids.range_check_ptr] = current_access_index"; @@ -332,6 +335,7 @@ mod tests { const SQUASH_DICT_INNER_NEXT_KEY: &str = "assert len(keys) > 0, 'No keys left but remaining_accesses > 0.'\nids.next_key = key = keys.pop()"; const SQUASH_DICT: &str ="dict_access_size = ids.DictAccess.SIZE\naddress = ids.dict_accesses.address_\nassert ids.ptr_diff % dict_access_size == 0, \\\n 'Accesses array size must be divisible by DictAccess.SIZE'\nn_accesses = ids.n_accesses\nif '__squash_dict_max_size' in globals():\n assert n_accesses <= __squash_dict_max_size, \\\n f'squash_dict() can only be used with n_accesses<={__squash_dict_max_size}. ' \\\n f'Got: n_accesses={n_accesses}.'\n# A map from key to the list of indices accessing it.\naccess_indices = {}\nfor i in range(n_accesses):\n key = memory[address + dict_access_size * i]\n access_indices.setdefault(key, []).append(i)\n# Descending list of keys.\nkeys = sorted(access_indices.keys(), reverse=True)\n# Are the keys used bigger than range_check bound.\nids.big_keys = 1 if keys[0] >= range_check_builtin.bound else 0\nids.first_key = key = keys.pop()"; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_valid() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //Prepare scope variables @@ -368,6 +372,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_empty_accessed_indices() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //Prepare scope variables @@ -393,6 +398,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_first_iteration_no_local_variables() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //No scope variables @@ -412,6 +418,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_skip_loop_valid_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_SKIP_LOOP; //Create vm @@ -430,6 +437,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_skip_loop_valid_non_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_SKIP_LOOP; //Create vm @@ -448,6 +456,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_check_access_index_valid() { let hint_code = SQUASH_DICT_INNER_CHECK_ACCESS_INDEX; //Create vm @@ -486,6 +495,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_check_access_current_access_addr_empty() { let hint_code = SQUASH_DICT_INNER_CHECK_ACCESS_INDEX; //Create vm @@ -509,6 +519,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_continue_loop_valid_non_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_CONTINUE_LOOP; //Create vm @@ -527,6 +538,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn should_continue_loop_valid_empty_current_access_indices() { let hint_code = SQUASH_DICT_INNER_CONTINUE_LOOP; //Create vm @@ -545,6 +557,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_current_indices_len_is_empty() { let hint_code = SQUASH_DICT_INNER_ASSERT_LEN; //Create vm @@ -560,6 +573,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_current_indices_len_is_empty_not() { let hint_code = SQUASH_DICT_INNER_ASSERT_LEN; //Create vm @@ -575,6 +589,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_valid() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -598,6 +613,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_wrong_used_access_number() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -627,6 +643,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_uses_accesses_assert_used_access_number_relocatable() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables @@ -652,6 +669,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_empty() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -666,6 +684,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_not_empty() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -680,6 +699,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_assert_len_keys_no_keys() { let hint_code = SQUASH_DICT_INNER_LEN_KEYS; //Create vm @@ -692,6 +712,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_next_key_keys_non_empty() { let hint_code = SQUASH_DICT_INNER_NEXT_KEY; //Create vm @@ -715,6 +736,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_inner_next_key_keys_empty() { let hint_code = SQUASH_DICT_INNER_NEXT_KEY; //Create vm @@ -733,6 +755,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_no_max_size() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -764,13 +787,12 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables + let access_indices_scope_value: HashMap> = + HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]); check_scope!( &exec_scopes, [ - ( - "access_indices", - HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]) - ), + ("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", Felt::one()) ] @@ -780,6 +802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_two_key_dict_no_max_size() { //Dict = {1: (1,1), 1: (1,2), 2: (10,10), 2: (10,20)} let hint_code = SQUASH_DICT; @@ -817,16 +840,14 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables + let access_indices_scope_value: HashMap> = HashMap::from([ + (Felt::one(), vec![Felt::zero(), Felt::one()]), + (Felt::new(2), vec![Felt::new(2), Felt::new(3)]), + ]); check_scope!( &exec_scopes, [ - ( - "access_indices", - HashMap::from([ - (Felt::one(), vec![Felt::zero(), Felt::one()]), - (Felt::new(2), vec![Felt::new(2), Felt::new(3)]) - ]) - ), + ("access_indices", access_indices_scope_value), ("keys", vec![Felt::new(2)]), ("key", Felt::one()) ] @@ -838,6 +859,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_with_max_size() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -870,13 +892,12 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables + let access_indices_scope_value: HashMap> = + HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]); check_scope!( &exec_scopes, [ - ( - "access_indices", - HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]) - ), + ("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", Felt::one()) ] @@ -886,6 +907,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_with_max_size_exceeded() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -926,6 +948,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_bad_ptr_diff() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -960,6 +983,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_invalid_one_key_dict_with_n_access_too_big() { //Dict = {1: (1,1), 1: (1,2)} let hint_code = SQUASH_DICT; @@ -1003,6 +1027,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn squash_dict_valid_one_key_dict_no_max_size_big_keys() { //Dict = {(prime - 1): (1,1), (prime - 1): (1,2)} let hint_code = SQUASH_DICT; @@ -1046,10 +1071,13 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - check_scope!(&exec_scopes, [("access_indices", HashMap::from([( - felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"), - vec![Felt::zero(), Felt::one()] - )])), ("keys", Vec::::new()), ("key", felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"))]); + let access_indices_scope_value: HashMap> = HashMap::from([( + felt_str!( + "3618502761706184546546682988428055018603476541694452277432519575032261771265" + ), + vec![Felt::zero(), Felt::one()], + )]); + check_scope!(&exec_scopes, [("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"))]); //Check ids variables check_memory![ vm.segments.memory, diff --git a/src/hint_processor/builtin_hint_processor/uint256_utils.rs b/src/hint_processor/builtin_hint_processor/uint256_utils.rs index f358b78713..155a497ec9 100644 --- a/src/hint_processor/builtin_hint_processor/uint256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/uint256_utils.rs @@ -1,3 +1,8 @@ +use crate::stdlib::{ + collections::HashMap, + ops::{Shl, Shr}, + prelude::*, +}; use crate::{ hint_processor::builtin_hint_processor::hint_utils::{ get_integer_from_var_name, get_relocatable_from_var_name, insert_value_from_var_name, @@ -11,10 +16,6 @@ use crate::{ use felt::Felt; use num_integer::div_rem; use num_traits::{One, Signed, Zero}; -use std::{ - collections::HashMap, - ops::{Shl, Shr}, -}; /* Implements hint: %{ @@ -240,9 +241,12 @@ mod tests { }; use assert_matches::assert_matches; use felt::felt_str; - use std::any::Any; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_add_ok() { let hint_code = "sum_low = ids.a.low + ids.b.low\nids.carry_low = 1 if sum_low >= ids.SHIFT else 0\nsum_high = ids.a.high + ids.b.high + ids.carry_low\nids.carry_high = 1 if sum_high >= ids.SHIFT else 0"; let mut vm = vm_with_range_check!(); @@ -264,6 +268,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_add_fail_inserts() { let hint_code = "sum_low = ids.a.low + ids.b.low\nids.carry_low = 1 if sum_low >= ids.SHIFT else 0\nsum_high = ids.a.high + ids.b.high + ids.carry_low\nids.carry_high = 1 if sum_high >= ids.SHIFT else 0"; let mut vm = vm_with_range_check!(); @@ -296,6 +301,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_ok() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -317,6 +323,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_with_big_a() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -339,6 +346,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_split_64_memory_error() { let hint_code = "ids.low = ids.a & ((1<<64) - 1)\nids.high = ids.a >> 64"; let mut vm = vm_with_range_check!(); @@ -367,6 +375,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_sqrt_ok() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -387,6 +396,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_sqrt_assert_error() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -408,6 +418,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_uint256_invalid_memory_insert() { let hint_code = "from starkware.python.math_utils import isqrt\nn = (ids.n.high << 128) + ids.n.low\nroot = isqrt(n)\nassert 0 <= root < 2 ** 128\nids.root.low = root\nids.root.high = 0"; let mut vm = vm_with_range_check!(); @@ -433,6 +444,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_result_one() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -456,6 +468,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_result_zero() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -479,6 +492,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_signed_nn_ok_invalid_memory_insert() { let hint_code = "memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0"; let mut vm = vm_with_range_check!(); @@ -503,6 +517,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unsigned_div_rem_ok() { let hint_code = "a = (ids.a.high << 128) + ids.a.low\ndiv = (ids.div.high << 128) + ids.div.low\nquotient, remainder = divmod(a, div)\n\nids.quotient.low = quotient & ((1 << 128) - 1)\nids.quotient.high = quotient >> 128\nids.remainder.low = remainder & ((1 << 128) - 1)\nids.remainder.high = remainder >> 128"; let mut vm = vm_with_range_check!(); @@ -527,6 +542,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_unsigned_div_rem_invalid_memory_insert() { let hint_code = "a = (ids.a.high << 128) + ids.a.low\ndiv = (ids.div.high << 128) + ids.div.low\nquotient, remainder = divmod(a, div)\n\nids.quotient.low = quotient & ((1 << 128) - 1)\nids.quotient.high = quotient >> 128\nids.remainder.low = remainder & ((1 << 128) - 1)\nids.remainder.high = remainder >> 128"; let mut vm = vm_with_range_check!(); diff --git a/src/hint_processor/builtin_hint_processor/usort.rs b/src/hint_processor/builtin_hint_processor/usort.rs index 72c8b8d6be..f85cbfa3a0 100644 --- a/src/hint_processor/builtin_hint_processor/usort.rs +++ b/src/hint_processor/builtin_hint_processor/usort.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, collections::HashMap, prelude::*}; + use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -11,7 +13,6 @@ use crate::{ }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; -use std::{any::Any, collections::HashMap}; pub fn usort_enter_scope(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { if let Ok(usort_max_size) = exec_scopes.get::("usort_max_size") { @@ -99,7 +100,7 @@ pub fn verify_usort( let value = get_integer_from_var_name("value", vm, ids_data, ap_tracking)?.clone(); let mut positions = exec_scopes .get_mut_dict_ref::>("positions_dict")? - .remove(&value) + .remove(value.as_ref()) .ok_or(HintError::UnexpectedPositionsDictFail)?; positions.reverse(); exec_scopes.insert_value("positions", positions); @@ -154,13 +155,18 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn usort_with_max_size() { let mut exec_scopes = scope![("usort_max_size", 1_u64)]; assert_matches!(usort_enter_scope(&mut exec_scopes), Ok(())); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn usort_out_of_range() { let mut vm = vm_with_range_check!(); vm.run_context.fp = 2; diff --git a/src/hint_processor/hint_processor_definition.rs b/src/hint_processor/hint_processor_definition.rs index 8e6bf56a47..5ba8335953 100644 --- a/src/hint_processor/hint_processor_definition.rs +++ b/src/hint_processor/hint_processor_definition.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, boxed::Box, collections::HashMap, prelude::*}; + use crate::any_box; use crate::serde::deserialize_program::ApTracking; use crate::serde::deserialize_program::OffsetValue; @@ -7,8 +9,6 @@ use crate::types::instruction::Register; use crate::vm::errors::hint_errors::HintError; use crate::vm::errors::vm_errors::VirtualMachineError; use crate::vm::vm_core::VirtualMachine; -use std::any::Any; -use std::collections::HashMap; use super::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; use felt::Felt; diff --git a/src/hint_processor/hint_processor_utils.rs b/src/hint_processor/hint_processor_utils.rs index 0a846e8b4a..894e72be5c 100644 --- a/src/hint_processor/hint_processor_utils.rs +++ b/src/hint_processor/hint_processor_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::borrow::Cow; + use crate::{ serde::deserialize_program::{ApTracking, OffsetValue}, types::{ @@ -7,7 +9,6 @@ use crate::{ }, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use std::borrow::Cow; use super::hint_processor_definition::HintReference; use felt::Felt; @@ -177,6 +178,7 @@ fn get_offset_value_reference( #[cfg(test)] mod tests { use super::*; + use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ relocatable, @@ -186,9 +188,12 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_from_reference_with_immediate_value() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -204,6 +209,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_offset_value_reference_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -217,6 +223,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_offset_value_reference_invalid() { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; @@ -230,6 +237,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_short_path() { let mut vm = vm!(); vm.segments = segments![((1, 0), (2, 0))]; @@ -245,6 +253,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_with_dereference() { let mut vm = vm!(); vm.segments = segments![((1, 0), (3, 0))]; @@ -260,6 +269,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ptr_from_reference_with_dereference_and_imm() { let mut vm = vm!(); vm.segments = segments![((1, 0), (4, 0))]; @@ -273,6 +283,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_addr_from_reference_no_regiter_in_reference() { let mut vm = vm!(); vm.segments = segments![((1, 0), (4, 0))]; @@ -283,6 +294,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_addr_from_reference_failed_to_get_ids() { let mut vm = vm!(); vm.segments = segments![((1, 0), 4)]; @@ -297,6 +309,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn tracking_correction_valid() { let mut ref_ap_tracking = ApTracking::new(); ref_ap_tracking.group = 1; @@ -310,6 +323,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn tracking_correction_invalid_group() { let mut ref_ap_tracking = ApTracking::new(); ref_ap_tracking.group = 1; @@ -325,6 +339,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_reference_valid() { let mut vm = vm!(); vm.segments = segments![((1, 0), (0, 0))]; @@ -336,6 +351,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_relocatable_from_reference_invalid() { let mut vm = vm!(); vm.segments.memory = Memory::new(); diff --git a/src/lib.rs b/src/lib.rs index 6bfda22c3c..021908a50a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,6 +7,52 @@ #![cfg_attr(docsrs, feature(doc_cfg))] #![deny(warnings)] +#![cfg_attr(any(target_arch = "wasm32", not(feature = "std")), no_std)] + +#[cfg(feature = "std")] +include!("./with_std.rs"); +#[cfg(all(not(feature = "std"), feature = "alloc"))] +include!("./with_alloc.rs"); +#[cfg(not(feature = "std"))] +include!("./without_std.rs"); + +mod stdlib { + pub mod collections { + #[cfg(all(not(feature = "std"), feature = "alloc"))] + pub use crate::with_alloc::collections::*; + #[cfg(feature = "std")] + pub use crate::with_std::collections::*; + } + + pub mod borrow { + #[cfg(all(not(feature = "std"), feature = "alloc"))] + pub use crate::with_alloc::borrow::*; + #[cfg(feature = "std")] + pub use crate::with_std::borrow::*; + #[cfg(not(feature = "std"))] + pub use crate::without_std::borrow::*; + } + + pub mod prelude { + pub use crate::stdlib::{ + borrow::ToOwned, + boxed::Box, + clone::Clone, + cmp::{Eq, PartialEq, Reverse}, + iter::IntoIterator, + string::{String, ToString}, + vec::Vec, + }; + } + + #[cfg(all(not(feature = "std"), feature = "alloc"))] + pub use crate::with_alloc::*; + #[cfg(feature = "std")] + pub use crate::with_std::*; + #[cfg(not(feature = "std"))] + pub use crate::without_std::*; +} + pub mod cairo_run; pub mod hint_processor; pub mod math_utils; @@ -14,3 +60,6 @@ pub mod serde; pub mod types; pub mod utils; pub mod vm; + +#[cfg(test)] +mod tests; diff --git a/src/math_utils.rs b/src/math_utils.rs index 70633c449a..0efd4293b5 100644 --- a/src/math_utils.rs +++ b/src/math_utils.rs @@ -1,9 +1,9 @@ +use crate::stdlib::ops::Shr; use crate::types::errors::math_errors::MathError; use felt::Felt; use num_bigint::{BigInt, BigUint}; use num_integer::Integer; use num_traits::{One, Signed, Zero}; -use std::ops::Shr; ///Returns the integer square root of the nonnegative integer n. ///This is the floor of the exact square root of n. @@ -165,7 +165,11 @@ mod tests { use assert_matches::assert_matches; use num_traits::Num; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_a() { let a = bigint_str!( "11260647941622813594563746375280766662237311019551239924981511729608487775604310196863705127454617186486639011517352066501847110680463498585797912894788" @@ -186,6 +190,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_b() { let a = bigint_str!( "29642372811668969595956851264770043260610851505766181624574941701711520154703788233010819515917136995474951116158286220089597404329949295479559895970988" @@ -206,6 +211,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_divmod_c() { let a = bigint_str!( "1208267356464811040667664150251401430616174694388968865551115897173431833224432165394286799069453655049199580362994484548890574931604445970825506916876" @@ -226,6 +232,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div() { let x = Felt::new(26); let y = Felt::new(13); @@ -233,6 +240,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_non_divisor() { let x = Felt::new(25); let y = Felt::new(4); @@ -245,6 +253,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_by_zero() { let x = Felt::new(25); let y = Felt::zero(); @@ -253,11 +262,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize() { assert_matches!(safe_div_usize(26, 13), Ok(2)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize_non_divisor() { assert_matches!( safe_div_usize(25, 4), @@ -266,11 +277,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_usize_by_zero() { assert_matches!(safe_div_usize(25, 0), Err(MathError::DividedByZero)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_line_slope_for_valid_points() { let point_a = ( bigint_str!( @@ -298,6 +311,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_double_slope_for_valid_point_a() { let point = ( bigint_str!( @@ -318,6 +332,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_double_slope_for_valid_point_b() { let point = ( bigint_str!( @@ -338,6 +353,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_a() { let point = ( bigint_str!( @@ -363,6 +379,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_b() { let point = ( bigint_str!( @@ -388,6 +405,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_double_for_valid_point_c() { let point = ( bigint_str!( @@ -413,6 +431,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_a() { let point_a = ( bigint_str!( @@ -445,6 +464,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_b() { let point_a = ( bigint_str!( @@ -477,6 +497,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_ec_add_for_valid_points_c() { let point_a = ( bigint_str!( @@ -509,18 +530,21 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_a() { let n = biguint!(81); assert_matches!(isqrt(&n), Ok(x) if x == biguint!(9)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_b() { let n = biguint_str!("4573659632505831259480"); assert_matches!(isqrt(&n.pow(2_u32)), Ok(num) if num == n); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_c() { let n = biguint_str!( "3618502788666131213697322783095070105623107215331596699973092056135872020481" @@ -529,6 +553,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn calculate_isqrt_zero() { let n = BigUint::zero(); assert_matches!(isqrt(&n), Ok(inner) if inner.is_zero()); diff --git a/src/serde/deserialize_program.rs b/src/serde/deserialize_program.rs index 7a540fc6b1..38216609fe 100644 --- a/src/serde/deserialize_program.rs +++ b/src/serde/deserialize_program.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{collections::HashMap, fmt, prelude::*}; + use crate::{ serde::deserialize_utils, types::{ @@ -13,7 +15,6 @@ use felt::{Felt, PRIME_STR}; use num_traits::Num; use serde::{de, de::MapAccess, de::SeqAccess, Deserialize, Deserializer, Serialize}; use serde_json::Number; -use std::{collections::HashMap, fmt, io::Read}; // This enum is used to deserialize program builtins into &str and catch non-valid names #[derive(Serialize, Deserialize, Debug, PartialEq, Copy, Clone, Eq)] @@ -329,17 +330,22 @@ pub fn deserialize_value_address<'de, D: Deserializer<'de>>( d.deserialize_str(ValueAddressVisitor) } -pub fn deserialize_program_json(reader: impl Read) -> Result { - let program_json = serde_json::from_reader(reader)?; +pub fn deserialize_program_json(reader: &[u8]) -> Result { + let program_json = serde_json::from_slice(reader)?; Ok(program_json) } - -pub fn deserialize_program( - reader: impl Read, +pub fn deserialize_and_parse_program( + reader: &[u8], entrypoint: Option<&str>, ) -> Result { let program_json: ProgramJson = deserialize_program_json(reader)?; + parse_program_json(program_json, entrypoint) +} +pub fn parse_program_json( + program_json: ProgramJson, + entrypoint: Option<&str>, +) -> Result { if PRIME_STR != program_json.prime { return Err(ProgramError::PrimeDiffers(program_json.prime)); } @@ -375,8 +381,8 @@ pub fn deserialize_program( let value = value .value .clone() - .ok_or_else(|| ProgramError::ConstWithoutValue(key.to_owned()))?; - constants.insert(key.to_owned(), value); + .ok_or_else(|| ProgramError::ConstWithoutValue(key.clone()))?; + constants.insert(key.clone(), value); } } @@ -405,9 +411,12 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::Zero; - use std::{fs::File, io::BufReader}; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_from_string_json_gives_error() { let invalid_even_length_hex_json = r#" { @@ -432,6 +441,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_invalid_char_error() { let invalid_char = r#" { @@ -444,6 +454,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_bigint_no_prefix_error() { let no_prefix = r#" { @@ -457,6 +468,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_from_string_json() { let valid_json = r#" { @@ -671,12 +683,12 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_a() { // Open json file with (valid) even length encoded hex - let file = File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); - let mut reader = BufReader::new(file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); - let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); + let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); assert_eq!( program_json.prime, @@ -688,12 +700,12 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_b() { // Open json file with (valid) odd length encoded hex - let file = File::open("cairo_programs/manually_compiled/valid_program_b.json").unwrap(); - let mut reader = BufReader::new(file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_b.json"); - let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); + let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); let builtins: Vec = vec![BuiltinName::output, BuiltinName::range_check]; assert_eq!( @@ -706,33 +718,32 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_json_from_json_file_gives_error() { // Open json file with (invalid) even length encoded hex - let even_length_file = - File::open("cairo_programs/manually_compiled/invalid_even_length_hex.json").unwrap(); - let mut reader = BufReader::new(even_length_file); + let reader = + include_bytes!("../../cairo_programs/manually_compiled/invalid_even_length_hex.json"); - let even_result: Result = serde_json::from_reader(&mut reader); + let even_result: Result = serde_json::from_slice(reader); assert!(even_result.is_err()); // Open json file with (invalid) odd length encoded hex - let odd_length_file = - File::open("cairo_programs/manually_compiled/invalid_odd_length_hex.json").unwrap(); - let mut reader = BufReader::new(odd_length_file); + let reader = + include_bytes!("../../cairo_programs/manually_compiled/invalid_odd_length_hex.json"); - let odd_result: Result = serde_json::from_reader(&mut reader); + let odd_result: Result = serde_json::from_slice(reader); assert!(odd_result.is_err()); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_missing_entrypoint_gives_error() { - let even_length_file = - File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); - let reader = BufReader::new(even_length_file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); - let deserialization_result = deserialize_program(reader, Some("missing_function")); + let deserialization_result = + deserialize_and_parse_program(reader, Some("missing_function")); assert!(deserialization_result.is_err()); assert_matches!( deserialization_result, @@ -741,13 +752,12 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_test() { - let even_length_file = - File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); - let reader = BufReader::new(even_length_file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); - let program: Program = - deserialize_program(reader, Some("main")).expect("Failed to deserialize program"); + let program: Program = deserialize_and_parse_program(reader, Some("main")) + .expect("Failed to deserialize program"); let builtins: Vec = Vec::new(); let data: Vec = vec![ @@ -804,13 +814,12 @@ mod tests { /// Deserialize a program without an entrypoint. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_without_entrypoint_test() { - let even_length_file = - File::open("cairo_programs/manually_compiled/valid_program_a.json").unwrap(); - let reader = BufReader::new(even_length_file); + let reader = include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"); let program: Program = - deserialize_program(reader, None).expect("Failed to deserialize program"); + deserialize_and_parse_program(reader, None).expect("Failed to deserialize program"); let builtins: Vec = Vec::new(); let data: Vec = vec![ @@ -866,12 +875,12 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_constant() { - let file = - File::open("cairo_programs/manually_compiled/deserialize_constant_test.json").unwrap(); - let mut reader = BufReader::new(file); + let reader = + include_bytes!("../../cairo_programs/manually_compiled/deserialize_constant_test.json"); - let program_json: ProgramJson = serde_json::from_reader(&mut reader).unwrap(); + let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); let mut identifiers: HashMap = HashMap::new(); identifiers.insert( @@ -960,6 +969,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn value_address_no_hint_reference_default_test() { let valid_json = r#" { @@ -1006,6 +1016,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_attributes_test() { let valid_json = r#" { @@ -1099,6 +1110,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_instruction_locations_test_no_parent() { let valid_json = r#" { @@ -1207,6 +1219,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_instruction_locations_test_with_parent() { let valid_json = r#" { @@ -1307,11 +1320,11 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_with_type_definition() { - let file = File::open("cairo_programs/uint256_integration_tests.json").unwrap(); - let reader = BufReader::new(file); + let reader = include_bytes!("../../cairo_programs/uint256_integration_tests.json"); - let program_json: ProgramJson = serde_json::from_reader(reader).unwrap(); + let program_json: ProgramJson = serde_json::from_slice(reader).unwrap(); assert_eq!( program_json.identifiers["starkware.cairo.common.alloc.alloc.Return"] diff --git a/src/serde/deserialize_utils.rs b/src/serde/deserialize_utils.rs index 22225dcdd3..e4c659b901 100644 --- a/src/serde/deserialize_utils.rs +++ b/src/serde/deserialize_utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{fmt, num::ParseIntError, prelude::*, str::FromStr}; + use crate::{ serde::deserialize_program::{OffsetValue, ValueAddress}, types::instruction::Register, @@ -17,7 +19,6 @@ use nom::{ }; use num_integer::Integer; use parse_hyperlinks::take_until_unbalanced; -use std::{fmt, num::ParseIntError, str::FromStr}; #[derive(Debug, PartialEq, Eq)] pub enum ReferenceParseError { @@ -174,9 +175,9 @@ pub fn parse_value(input: &str) -> IResult<&str, ValueAddress> { tuple((tag(", "), take_till(|c: char| c == '*')))(second_arg)?; let type_: String = if let Some(indirections) = indirection_level.get(1..) { - struct_.to_owned() + indirections + struct_.to_string() + indirections } else { - struct_.to_owned() + struct_.to_string() }; let fst_offset = fst_offset.unwrap_or(OffsetValue::Value(0)); @@ -214,9 +215,14 @@ pub fn parse_value(input: &str) -> IResult<&str, ValueAddress> { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::string::ToString; use num_traits::{One, Zero}; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn outer_brackets_test() { let deref_value = "[cast([fp])]"; let parsed_deref = outer_brackets(deref_value); @@ -228,6 +234,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn take_cast_test() { let value = "cast([fp + (-1)], felt*)"; let parsed = take_cast(value); @@ -235,6 +242,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn take_cast_first_arg_test() { let value = "cast([fp + (-1)] + (-1), felt*)"; let parsed = take_cast_first_arg(value); @@ -243,6 +251,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_register_test() { let value = "fp + (-1)"; let parsed = register(value); @@ -251,6 +260,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_offset_test() { let value_1 = " + (-1)"; let parsed_1 = offset(value_1); @@ -266,6 +276,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_register_and_offset_test() { let value_1 = "fp + 1"; let parsed_1 = register_and_offset(value_1); @@ -279,6 +290,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_inner_dereference_test() { let value = "[fp + (-1)] + 2"; let parsed = inner_dereference(value); @@ -290,6 +302,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_no_inner_dereference_test() { let value = "ap + 3"; let parsed = no_inner_dereference(value); @@ -301,6 +314,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_dereference_test() { let value = "[cast([fp + (-1)] + 2, felt*)]"; let parsed = parse_value(value); @@ -320,6 +334,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_inner_dereference_test() { let value = "cast(ap + 2, felt*)"; let parsed = parse_value(value); @@ -339,6 +354,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_register_test() { let value = "cast(825323, felt*)"; let parsed = parse_value(value); @@ -357,6 +373,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_inner_deref_and_two_offsets() { let value = "[cast(ap - 0 + (-1), felt*)]"; let parsed = parse_value(value); @@ -376,6 +393,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_and_offset2() { let value = "[cast([ap] + 1, __main__.felt*)]"; let parsed = parse_value(value); @@ -395,6 +413,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_and_immediate() { let value = "[cast([ap] + 1, felt)]"; let parsed = parse_value(value); @@ -414,6 +433,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_inner_deref_to_pointer() { let value = "[cast([ap + 1] + 1, felt*)]"; let parsed = parse_value(value); @@ -433,6 +453,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_2_inner_deref() { let value = "[cast([ap] + [fp + 1], __main__.felt*)]"; let parsed = parse_value(value); @@ -452,6 +473,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_2_inner_dereferences() { let value = "[cast([ap + 1] + [fp + 1], __main__.felt*)]"; let parsed = parse_value(value); @@ -471,6 +493,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_no_reference() { let value = "cast(825323, felt)"; let parsed = parse_value(value); @@ -490,6 +513,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_one_reference() { let value = "[cast([ap] + 1, starkware.cairo.common.cairo_secp.ec.EcPoint*)]"; let parsed = parse_value(value); @@ -509,6 +533,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_with_doble_reference() { let value = "[cast([ap] + 1, starkware.cairo.common.cairo_secp.ec.EcPoint**)]"; let parsed = parse_value(value); @@ -528,6 +553,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_to_felt_with_doble_reference() { let value = "[cast([ap] + [ap], felt)]"; let parsed = parse_value(value); @@ -547,6 +573,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn parse_value_to_felt_with_doble_reference_and_offsets() { let value = "[cast([ap + 1] + [ap + 2], felt)]"; let parsed = parse_value(value); diff --git a/tests/bitwise_test.rs b/src/tests/bitwise_test.rs similarity index 94% rename from tests/bitwise_test.rs rename to src/tests/bitwise_test.rs index c2b5cf14d6..7fc819b4fe 100644 --- a/tests/bitwise_test.rs +++ b/src/tests/bitwise_test.rs @@ -1,4 +1,6 @@ -use cairo_vm::{ +use crate::stdlib::prelude::*; + +use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::{ @@ -7,17 +9,19 @@ use cairo_vm::{ }, }; -#[macro_use] -extern crate assert_matches; +use assert_matches::assert_matches; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; -use std::path::Path; #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn bitwise_integration_test() { - let program = Program::from_file( - Path::new("cairo_programs/bitwise_builtin_test.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/bitwise_builtin_test.json"), Some("main"), ) - .expect("Failed to deserialize program"); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); diff --git a/src/tests/cairo_run_test.rs b/src/tests/cairo_run_test.rs new file mode 100644 index 0000000000..8930d3c7aa --- /dev/null +++ b/src/tests/cairo_run_test.rs @@ -0,0 +1,1402 @@ +use crate::stdlib::prelude::*; + +use crate::cairo_run::{self, CairoRunConfig}; +use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn fibonacci() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/fibonacci.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn array_sum() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/array_sum.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn big_struct() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/big_struct.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn call_function_assign_param_by_name() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/call_function_assign_param_by_name.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn function_return() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/function_return.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn function_return_if_print() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/function_return_if_print.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn function_return_to_variable() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/function_return_to_variable.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn if_and_prime() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/if_and_prime.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn if_in_function() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/if_in_function.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn if_list() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/if_list.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn jmp() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/jmp.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn jmp_if_condition() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/jmp_if_condition.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn pointers() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/pointers.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn print() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/print.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn program_return() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/return.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn reversed_register_instructions() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/reversed_register_instructions.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn simple_print() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/simple_print.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn test_addition_if() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/test_addition_if.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn test_reverse_if() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/test_reverse_if.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn test_subtraction_if() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/test_subtraction_if.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn use_imported_module() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/use_imported_module.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bitwise_output() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bitwise_output.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bitwise_recursion() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bitwise_recursion.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn integration() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/integration.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn integration_with_alloc_locals() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/integration_with_alloc_locals.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn compare_arrays() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/compare_arrays.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn compare_greater_array() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/compare_greater_array.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn compare_lesser_array() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/compare_lesser_array.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_le_felt_hint() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_le_felt_hint.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_250_bit_element_array() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_250_bit_element_array.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn abs_value_array() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/abs_value_array.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn compare_different_arrays() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/compare_different_arrays.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_nn() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_nn.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn sqrt() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/sqrt.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_not_zero() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_not_zero.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn split_int() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/split_int.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn split_int_big() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/split_int_big.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn split_felt() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/split_felt.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn math_cmp() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/math_cmp.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn unsigned_div_rem() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/unsigned_div_rem.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn signed_div_rem() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/signed_div_rem.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn assert_lt_felt() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/assert_lt_felt.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn memcpy_test() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/memcpy_test.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn memset() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/memset.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn pow() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/pow.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict_update() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict_update.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn uint256() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/uint256.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn find_element() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/find_element.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn search_sorted_lower() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/search_sorted_lower.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn usort() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/usort.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn squash_dict() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/squash_dict.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict_squash() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict_squash.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn set_add() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/set_add.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn secp() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/secp.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn signature() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/signature.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn secp_ec() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/secp_ec.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn blake2s_hello_world_hash() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/blake2s_hello_world_hash.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn finalize_blake2s() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/finalize_blake2s.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn unsafe_keccak() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/unsafe_keccak.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn blake2s_felts() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/blake2s_felts.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn unsafe_keccak_finalize() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/unsafe_keccak_finalize.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn keccak_add_uint256() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/keccak_add_uint256.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn keccak() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/_keccak.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn keccak_copy_inputs() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/keccak_copy_inputs.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn cairo_finalize_keccak() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/cairo_finalize_keccak.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn operations_with_data_structures() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/operations_with_data_structures.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn sha256() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/sha256.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn math_cmp_and_pow_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/math_cmp_and_pow_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn uint256_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/uint256_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn set_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/set_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn memory_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/memory_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn secp_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/secp_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn keccak_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/keccak_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn blake2s_integration_tests() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/blake2s_integration_tests.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn relocate_segments() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/relocate_segments.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn dict_store_cast_ptr() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/dict_store_cast_ptr.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn common_signature() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/common_signature.json"); + cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bad_usort() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/bad_usort.json"); + let expected_error_message = "unexpected verify multiplicity fail: positions length != 0"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bad_dict_new() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/bad_dict_new.json"); + let expected_error_message = "Dict Error: Tried to create a dict whithout an initial dict"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn bad_dict_update() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/bad_dict_update.json"); + let expected_error_message = + "Dict Error: Got the wrong value for dict_update, expected value: 3, got: 5 for key: 2"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn error_msg_attr() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr.json"); + let expected_error_message = "SafeUint256: addition overflow"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn error_msg_attr_tempvar() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"); + + #[cfg(feature = "std")] + let expected_error_message = "Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n assert x = 2;\n ^***********^\n"; + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_error_message = "Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} + +#[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +fn error_msg_attr_struct() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let file = include_bytes!("../../cairo_programs/bad_programs/error_msg_attr_struct.json"); + let expected_error_message = "Error message: Cats cannot have more than nine lives: {cat} (Cannot evaluate ap-based or complex references: ['cat'])"; + let res = cairo_run::cairo_run( + file, + &CairoRunConfig { + layout: "all", + ..Default::default() + }, + &mut hint_executor, + ); + assert!(&res + .err() + .unwrap() + .to_string() + .contains(expected_error_message)); +} diff --git a/tests/compare_vm_state.sh b/src/tests/compare_vm_state.sh similarity index 100% rename from tests/compare_vm_state.sh rename to src/tests/compare_vm_state.sh diff --git a/tests/memory_comparator.py b/src/tests/memory_comparator.py similarity index 100% rename from tests/memory_comparator.py rename to src/tests/memory_comparator.py diff --git a/src/tests/mod.rs b/src/tests/mod.rs new file mode 100644 index 0000000000..47c3be4d51 --- /dev/null +++ b/src/tests/mod.rs @@ -0,0 +1,7 @@ +mod bitwise_test; +mod cairo_run_test; +mod pedersen_test; +mod struct_test; + +#[cfg(feature = "skip_next_instruction_hint")] +mod skip_instruction_test; diff --git a/tests/pedersen_test.rs b/src/tests/pedersen_test.rs similarity index 87% rename from tests/pedersen_test.rs rename to src/tests/pedersen_test.rs index 0392243d69..bc21549338 100644 --- a/tests/pedersen_test.rs +++ b/src/tests/pedersen_test.rs @@ -1,17 +1,25 @@ -use std::path::Path; -#[macro_use] -extern crate assert_matches; -use cairo_vm::{ +use crate::stdlib::prelude::*; + +use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::trace::trace_entry::RelocatedTraceEntry, vm::{runners::cairo_runner::CairoRunner, vm_core::VirtualMachine}, }; +use assert_matches::assert_matches; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; + #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn pedersen_integration_test() { - let program = Program::from_file(Path::new("cairo_programs/pedersen_test.json"), Some("main")) - .expect("Failed to deserialize program"); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/pedersen_test.json"), + Some("main"), + ) + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); diff --git a/tests/skip_instruction_test.rs b/src/tests/skip_instruction_test.rs similarity index 61% rename from tests/skip_instruction_test.rs rename to src/tests/skip_instruction_test.rs index c8675e58a5..d781c8faac 100644 --- a/tests/skip_instruction_test.rs +++ b/src/tests/skip_instruction_test.rs @@ -1,23 +1,24 @@ -#[cfg(feature = "skip_next_instruction_hint")] -use cairo_vm::{ +use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, vm::{runners::cairo_runner::CairoRunner, vm_core::VirtualMachine}, }; -#[macro_use] -extern crate assert_matches; -#[cfg(feature = "skip_next_instruction_hint")] -use std::path::Path; +use assert_matches::assert_matches; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; -#[cfg(feature = "skip_next_instruction_hint")] #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn skip_next_instruction_test() { - let program = Program::from_file( - Path::new("cairo_programs/noretrocompat/test_skip_next_instruction.noretrocompat.json"), + let program = Program::from_bytes( + include_bytes!( + "../../cairo_programs/noretrocompat/test_skip_next_instruction.noretrocompat.json" + ), Some("main"), ) - .expect("Failed to deserialize program"); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); diff --git a/tests/struct_test.rs b/src/tests/struct_test.rs similarity index 63% rename from tests/struct_test.rs rename to src/tests/struct_test.rs index cd443c051f..72b7f65d86 100644 --- a/tests/struct_test.rs +++ b/src/tests/struct_test.rs @@ -1,21 +1,23 @@ -use cairo_vm::{ +use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, - vm::vm_core::VirtualMachine, + types::program::Program, vm::vm_core::VirtualMachine, }; -use std::path::Path; -use cairo_vm::{ - types::program::Program, - vm::{runners::cairo_runner::CairoRunner, trace::trace_entry::RelocatedTraceEntry}, -}; +use crate::vm::{runners::cairo_runner::CairoRunner, trace::trace_entry::RelocatedTraceEntry}; + +use assert_matches::assert_matches; -#[macro_use] -extern crate assert_matches; +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn struct_integration_test() { - let program = Program::from_file(Path::new("cairo_programs/struct.json"), Some("main")) - .expect("Failed to deserialize program"); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/struct.json"), + Some("main"), + ) + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap(); let mut vm = VirtualMachine::new(true); diff --git a/src/types/errors/math_errors.rs b/src/types/errors/math_errors.rs index dbe06dde19..4cb1b71ace 100644 --- a/src/types/errors/math_errors.rs +++ b/src/types/errors/math_errors.rs @@ -1,6 +1,10 @@ use felt::Felt; use num_bigint::{BigInt, BigUint}; + +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; diff --git a/src/types/errors/program_errors.rs b/src/types/errors/program_errors.rs index c74d7456d3..9a8437e7d5 100644 --- a/src/types/errors/program_errors.rs +++ b/src/types/errors/program_errors.rs @@ -1,11 +1,17 @@ -use felt::PRIME_STR; -use std::io; +use crate::stdlib::prelude::*; + +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + +use felt::PRIME_STR; #[derive(Debug, Error)] pub enum ProgramError { + #[cfg(feature = "std")] #[error(transparent)] - IO(#[from] io::Error), + IO(#[from] std::io::Error), #[error(transparent)] Parse(#[from] serde_json::Error), #[error("Entrypoint {0} not found")] @@ -20,7 +26,11 @@ pub enum ProgramError { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn format_entrypoint_not_found_error() { let error = ProgramError::EntrypointNotFound(String::from("my_function")); let formatted_error = format!("{error}"); diff --git a/src/types/exec_scope.rs b/src/types/exec_scope.rs index 1721d02f17..941525e26b 100644 --- a/src/types/exec_scope.rs +++ b/src/types/exec_scope.rs @@ -1,10 +1,11 @@ +use crate::stdlib::{any::Any, cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; use crate::{ any_box, hint_processor::builtin_hint_processor::dict_manager::DictManager, vm::errors::{exec_scope_errors::ExecScopeError, hint_errors::HintError}, }; -use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; +#[derive(Debug)] pub struct ExecutionScopes { pub data: Vec>>, } @@ -190,13 +191,18 @@ mod tests { use felt::Felt; use num_traits::One; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_execution_scopes() { let scopes = ExecutionScopes::new(); assert_eq!(scopes.data.len(), 1); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_local_variables_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -217,6 +223,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn enter_new_scope_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2_i32)); @@ -259,6 +266,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -295,6 +303,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assign_local_variable_test() { let var_value: Box = Box::new(Felt::new(2)); @@ -315,6 +324,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn re_assign_local_variable_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -340,6 +350,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn delete_local_variable_test() { let var_name = String::from("a"); let var_value: Box = Box::new(Felt::new(2)); @@ -362,6 +373,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_main_scope_gives_error_test() { let mut scopes = ExecutionScopes::new(); @@ -369,6 +381,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_listu64_test() { let list_u64: Box = Box::new(vec![20_u64, 18_u64]); @@ -390,6 +403,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_u64_test() { let u64: Box = Box::new(9_u64); @@ -415,6 +429,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_mut_int_ref_test() { let bigint: Box = Box::new(Felt::new(12)); @@ -428,6 +443,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_any_boxed_test() { let list_u64: Box = Box::new(vec![20_u64, 18_u64]); diff --git a/src/types/instance_definitions/bitwise_instance_def.rs b/src/types/instance_definitions/bitwise_instance_def.rs index 0f1a6c5b04..8cea97d21b 100644 --- a/src/types/instance_definitions/bitwise_instance_def.rs +++ b/src/types/instance_definitions/bitwise_instance_def.rs @@ -35,19 +35,25 @@ impl BitwiseInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = BitwiseInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = BitwiseInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 5); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = BitwiseInstanceDef { ratio: 8, @@ -57,6 +63,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = BitwiseInstanceDef { ratio: 256, diff --git a/src/types/instance_definitions/builtins_instance_def.rs b/src/types/instance_definitions/builtins_instance_def.rs index c29ee400b2..95be8bb98f 100644 --- a/src/types/instance_definitions/builtins_instance_def.rs +++ b/src/types/instance_definitions/builtins_instance_def.rs @@ -105,7 +105,11 @@ impl BuiltinsInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_plain() { let builtins = BuiltinsInstanceDef::plain(); assert!(!builtins.output); @@ -117,6 +121,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_small() { let builtins = BuiltinsInstanceDef::small(); assert!(builtins.output); @@ -128,6 +133,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_dex() { let builtins = BuiltinsInstanceDef::dex(); assert!(builtins.output); @@ -139,6 +145,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_perpetual_with_bitwise() { let builtins = BuiltinsInstanceDef::perpetual_with_bitwise(); assert!(builtins.output); @@ -150,6 +157,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_bitwise() { let builtins = BuiltinsInstanceDef::bitwise(); assert!(builtins.output); @@ -161,6 +169,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_recursive() { let builtins = BuiltinsInstanceDef::recursive(); assert!(builtins.output); @@ -172,6 +181,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_all() { let builtins = BuiltinsInstanceDef::all(); assert!(builtins.output); diff --git a/src/types/instance_definitions/cpu_instance_def.rs b/src/types/instance_definitions/cpu_instance_def.rs index 7aa89b2e17..0bee2496ea 100644 --- a/src/types/instance_definitions/cpu_instance_def.rs +++ b/src/types/instance_definitions/cpu_instance_def.rs @@ -13,7 +13,11 @@ impl CpuInstanceDef { mod tests { use super::CpuInstanceDef; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let cpu_instance = CpuInstanceDef::default(); assert!(cpu_instance._safe_call) diff --git a/src/types/instance_definitions/diluted_pool_instance_def.rs b/src/types/instance_definitions/diluted_pool_instance_def.rs index 7a7f756c45..8138c573bd 100644 --- a/src/types/instance_definitions/diluted_pool_instance_def.rs +++ b/src/types/instance_definitions/diluted_pool_instance_def.rs @@ -27,7 +27,11 @@ impl DilutedPoolInstanceDef { mod tests { use super::DilutedPoolInstanceDef; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let diluted_pool = DilutedPoolInstanceDef::default(); assert_eq!(diluted_pool.units_per_step, 16); @@ -36,6 +40,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let diluted_pool = DilutedPoolInstanceDef::new(1, 1, 1); assert_eq!(diluted_pool.units_per_step, 1); diff --git a/src/types/instance_definitions/ec_op_instance_def.rs b/src/types/instance_definitions/ec_op_instance_def.rs index 03083c6866..f777589842 100644 --- a/src/types/instance_definitions/ec_op_instance_def.rs +++ b/src/types/instance_definitions/ec_op_instance_def.rs @@ -38,19 +38,25 @@ impl EcOpInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = EcOpInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = EcOpInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 7); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = EcOpInstanceDef { ratio: 8, @@ -61,6 +67,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = EcOpInstanceDef { ratio: 256, diff --git a/src/types/instance_definitions/ecdsa_instance_def.rs b/src/types/instance_definitions/ecdsa_instance_def.rs index fdd48c1d3f..689443f682 100644 --- a/src/types/instance_definitions/ecdsa_instance_def.rs +++ b/src/types/instance_definitions/ecdsa_instance_def.rs @@ -41,19 +41,25 @@ impl EcdsaInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = EcdsaInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = EcdsaInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 2); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = EcdsaInstanceDef { ratio: 8, @@ -65,6 +71,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = EcdsaInstanceDef { ratio: 512, diff --git a/src/types/instance_definitions/keccak_instance_def.rs b/src/types/instance_definitions/keccak_instance_def.rs index d1bf77195e..d01c666622 100644 --- a/src/types/instance_definitions/keccak_instance_def.rs +++ b/src/types/instance_definitions/keccak_instance_def.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + #[derive(Clone, Debug, PartialEq)] pub(crate) struct KeccakInstanceDef { pub(crate) _ratio: u32, @@ -38,19 +40,25 @@ impl KeccakInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = KeccakInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = KeccakInstanceDef::default(); assert_eq!(builtin_instance.cells_per_builtin(), 16); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = KeccakInstanceDef { _ratio: 2048, @@ -61,6 +69,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = KeccakInstanceDef { _ratio: 2048, diff --git a/src/types/instance_definitions/pedersen_instance_def.rs b/src/types/instance_definitions/pedersen_instance_def.rs index bd225d059c..dad14cdebb 100644 --- a/src/types/instance_definitions/pedersen_instance_def.rs +++ b/src/types/instance_definitions/pedersen_instance_def.rs @@ -49,19 +49,25 @@ impl PedersenInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = PedersenInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = PedersenInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 3); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = PedersenInstanceDef { ratio: 10, @@ -75,6 +81,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = PedersenInstanceDef { ratio: 8, diff --git a/src/types/instance_definitions/range_check_instance_def.rs b/src/types/instance_definitions/range_check_instance_def.rs index 24057a7888..bc67866e8a 100644 --- a/src/types/instance_definitions/range_check_instance_def.rs +++ b/src/types/instance_definitions/range_check_instance_def.rs @@ -31,19 +31,25 @@ impl RangeCheckInstanceDef { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_units_per_builtin() { let builtin_instance = RangeCheckInstanceDef::default(); assert_eq!(builtin_instance._range_check_units_per_builtin(), 8); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_builtin() { let builtin_instance = RangeCheckInstanceDef::default(); assert_eq!(builtin_instance._cells_per_builtin(), 1); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_new() { let builtin_instance = RangeCheckInstanceDef { ratio: 10, @@ -53,6 +59,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_default() { let builtin_instance = RangeCheckInstanceDef { ratio: 8, diff --git a/src/types/instruction.rs b/src/types/instruction.rs index f6f7590d23..d3d43866e9 100644 --- a/src/types/instruction.rs +++ b/src/types/instruction.rs @@ -103,7 +103,11 @@ pub(crate) fn is_call_instruction(encoded_instruction: &Felt, imm: Option<&Felt> mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_call_instruction_true() { let encoded_instruction = Felt::new(1226245742482522112_i64); assert!(is_call_instruction( @@ -112,12 +116,14 @@ mod tests { )); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_call_instruction_false() { let encoded_instruction = Felt::new(4612671187288031229_i64); assert!(!is_call_instruction(&encoded_instruction, None)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn instruction_size() { let encoded_instruction = Felt::new(1226245742482522112_i64); let instruction = diff --git a/src/types/layout.rs b/src/types/layout.rs index 1e37c654a5..3d9e7cebab 100644 --- a/src/types/layout.rs +++ b/src/types/layout.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use super::instance_definitions::{ builtins_instance_def::BuiltinsInstanceDef, cpu_instance_def::CpuInstanceDef, diluted_pool_instance_def::DilutedPoolInstanceDef, @@ -120,7 +122,11 @@ impl CairoLayout { mod tests { use super::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_plain_instance() { let layout = CairoLayout::plain_instance(); let builtins = BuiltinsInstanceDef::plain(); @@ -136,6 +142,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_small_instance() { let layout = CairoLayout::small_instance(); let builtins = BuiltinsInstanceDef::small(); @@ -151,6 +158,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_dex_instance() { let layout = CairoLayout::dex_instance(); let builtins = BuiltinsInstanceDef::dex(); @@ -166,6 +174,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perpetual_with_bitwise_instance() { let layout = CairoLayout::perpetual_with_bitwise_instance(); let builtins = BuiltinsInstanceDef::perpetual_with_bitwise(); @@ -184,6 +193,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_bitwise_instance() { let layout = CairoLayout::bitwise_instance(); let builtins = BuiltinsInstanceDef::bitwise(); @@ -202,6 +212,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_recursive_instance() { let layout = CairoLayout::recursive_instance(); let builtins = BuiltinsInstanceDef::recursive(); @@ -220,6 +231,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_all_instance() { let layout = CairoLayout::all_instance(); let builtins = BuiltinsInstanceDef::all(); diff --git a/src/types/program.rs b/src/types/program.rs index 04df56fcbc..f96913e287 100644 --- a/src/types/program.rs +++ b/src/types/program.rs @@ -1,17 +1,17 @@ +use crate::stdlib::{collections::HashMap, prelude::*}; + use crate::{ serde::deserialize_program::{ - deserialize_program, Attribute, BuiltinName, HintParams, Identifier, InstructionLocation, - ReferenceManager, + deserialize_and_parse_program, Attribute, BuiltinName, HintParams, Identifier, + InstructionLocation, ReferenceManager, }, types::{errors::program_errors::ProgramError, relocatable::MaybeRelocatable}, }; use felt::{Felt, PRIME_STR}; use serde::{Deserialize, Serialize}; -use std::{ - fs::File, - io::{BufReader, Read}, - {collections::HashMap, path::Path}, -}; + +#[cfg(feature = "std")] +use std::path::Path; #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct Program { @@ -54,8 +54,8 @@ impl Program { let value = value .value .clone() - .ok_or_else(|| ProgramError::ConstWithoutValue(key.to_owned()))?; - constants.insert(key.to_owned(), value); + .ok_or_else(|| ProgramError::ConstWithoutValue(key.clone()))?; + constants.insert(key.clone(), value); } } @@ -72,18 +72,14 @@ impl Program { }) } + #[cfg(feature = "std")] pub fn from_file(path: &Path, entrypoint: Option<&str>) -> Result { - let file = File::open(path)?; - let reader = BufReader::new(file); - - deserialize_program(reader, entrypoint) + let file_content = std::fs::read(path)?; + deserialize_and_parse_program(&file_content, entrypoint) } - pub fn from_reader( - reader: impl Read, - entrypoint: Option<&str>, - ) -> Result { - deserialize_program(reader, entrypoint) + pub fn from_bytes(bytes: &[u8], entrypoint: Option<&str>) -> Result { + deserialize_and_parse_program(bytes, entrypoint) } } @@ -111,11 +107,15 @@ impl Default for Program { mod tests { use super::*; use crate::serde::deserialize_program::{ApTracking, FlowTrackingData}; - use crate::utils::test_utils::mayberelocatable; + use crate::utils::test_utils::*; use felt::felt_str; use num_traits::Zero; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -151,6 +151,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new_program_with_identifiers() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -220,6 +221,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn new_program_with_invalid_identifiers() { let reference_manager = ReferenceManager { references: Vec::new(), @@ -278,12 +280,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_test() { - let program: Program = Program::from_file( - Path::new("cairo_programs/manually_compiled/valid_program_a.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"), Some("main"), ) - .expect("Failed to deserialize program"); + .unwrap(); let builtins: Vec = Vec::new(); let data: Vec = vec![ @@ -362,12 +365,13 @@ mod tests { /// Deserialize a program without an entrypoint. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_without_entrypoint_test() { - let program: Program = Program::from_file( - Path::new("cairo_programs/manually_compiled/valid_program_a.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/manually_compiled/valid_program_a.json"), None, ) - .expect("Failed to deserialize program"); + .unwrap(); let builtins: Vec = Vec::new(); @@ -461,12 +465,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deserialize_program_constants_test() { - let program = Program::from_file( - Path::new("cairo_programs/manually_compiled/deserialize_constant_test.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/manually_compiled/deserialize_constant_test.json"), Some("main"), ) - .expect("Failed to deserialize program"); + .unwrap(); let constants = [ ("__main__.compare_abs_arrays.SIZEOF_LOCALS", Felt::zero()), @@ -499,6 +504,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn default_program() { let program = Program { builtins: Vec::new(), diff --git a/src/types/relocatable.rs b/src/types/relocatable.rs index 2b3bae84fc..36719ab182 100644 --- a/src/types/relocatable.rs +++ b/src/types/relocatable.rs @@ -1,13 +1,15 @@ +use crate::stdlib::{ + fmt::{self, Display}, + ops::{Add, AddAssign, Sub}, + prelude::*, +}; + use crate::{ relocatable, types::errors::math_errors::MathError, vm::errors::memory_errors::MemoryError, }; use felt::Felt; use num_traits::{ToPrimitive, Zero}; use serde::{Deserialize, Serialize}; -use std::{ - fmt::{self, Display}, - ops::{Add, AddAssign, Sub}, -}; #[derive(Eq, Hash, PartialEq, PartialOrd, Clone, Copy, Debug, Serialize, Deserialize)] pub struct Relocatable { @@ -354,7 +356,11 @@ mod tests { use felt::felt_str; use num_traits::{One, Zero}; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_int() { let addr = MaybeRelocatable::from(Felt::new(7i32)); let added_addr = addr.add_int(&Felt::new(2i32)); @@ -362,6 +368,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_usize_to_int() { let addr = MaybeRelocatable::from(Felt::new(7_i32)); let added_addr = addr.add_usize(2).unwrap(); @@ -369,6 +376,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_relocatable() { let addr = MaybeRelocatable::RelocatableValue(relocatable!(7, 65)); let added_addr = addr.add_int(&Felt::new(2)); @@ -382,6 +390,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_mod_offset_exceeded() { let addr = MaybeRelocatable::from((0, 0)); let error = addr.add_int(&felt_str!("18446744073709551616")); @@ -395,6 +404,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_usize_to_relocatable() { let addr = MaybeRelocatable::RelocatableValue(relocatable!(7, 65)); let added_addr = addr.add_usize(2); @@ -408,6 +418,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_int_prime_mod() { let addr = MaybeRelocatable::Int(felt_str!( "800000000000011000000000000000000000000000000000000000000000004", @@ -418,6 +429,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_relocatable_prime() { let addr = MaybeRelocatable::from((1, 9)); let added_addr = addr.add_int(&felt_str!( @@ -433,6 +445,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_int() { let addr_a = &MaybeRelocatable::from(felt_str!( "3618502788666131213697322783095070105623107215331596699973092056135872020488" @@ -443,6 +456,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocatable_to_relocatable_should_fail() { let addr_a = &MaybeRelocatable::from((7, 5)); let addr_b = &MaybeRelocatable::RelocatableValue(relocatable!(7, 10)); @@ -457,6 +471,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_relocatable() { let addr_a = &MaybeRelocatable::from((7, 7)); let addr_b = &MaybeRelocatable::from(Felt::new(10)); @@ -471,6 +486,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocatable_to_int() { let addr_a = &MaybeRelocatable::from(Felt::new(10_i32)); let addr_b = &MaybeRelocatable::RelocatableValue(relocatable!(7, 7)); @@ -485,6 +501,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_relocatable_prime() { let addr_a = &MaybeRelocatable::from((7, 14)); let addr_b = &MaybeRelocatable::Int(felt_str!( @@ -502,6 +519,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_rel_int_offset_exceeded() { let addr = MaybeRelocatable::from((0, 0)); let error = addr.add(&MaybeRelocatable::from(felt_str!("18446744073709551616"))); @@ -515,6 +533,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_int_rel_offset_exceeded() { let addr = MaybeRelocatable::Int(felt_str!("18446744073709551616")); let relocatable = Relocatable { @@ -532,6 +551,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_int_from_int() { let addr_a = &MaybeRelocatable::from(Felt::new(7)); let addr_b = &MaybeRelocatable::from(Felt::new(5)); @@ -540,6 +560,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_relocatable_from_relocatable_same_offset() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from((7, 7)); @@ -548,6 +569,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_relocatable_from_relocatable_diff_offset() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from((8, 7)); @@ -562,6 +584,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_int_addr_ref_from_relocatable_addr_ref() { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from(Felt::new(5_i32)); @@ -570,6 +593,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_rel_to_int_error() { assert_eq!( MaybeRelocatable::from(Felt::new(7_i32)).sub(&MaybeRelocatable::from((7, 10))), @@ -581,6 +605,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn divmod_working() { let value = &MaybeRelocatable::from(Felt::new(10)); let div = &MaybeRelocatable::from(Felt::new(3)); @@ -590,6 +615,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn divmod_bad_type() { let value = &MaybeRelocatable::from(Felt::new(10)); let div = &MaybeRelocatable::from((2, 7)); @@ -603,6 +629,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value() { let value = MaybeRelocatable::from((2, 7)); let relocation_table = vec![1, 2, 5]; @@ -610,6 +637,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -620,6 +648,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value_with_offset() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -630,6 +659,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_in_temp_segment_value_error() { let value = MaybeRelocatable::from((-1, 7)); let relocation_table = vec![1, 2, 5]; @@ -640,6 +670,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_int_value() { let value = MaybeRelocatable::from(Felt::new(7)); let relocation_table = vec![1, 2, 5]; @@ -647,6 +678,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value_no_relocation() { let value = MaybeRelocatable::from((2, 7)); let relocation_table = vec![1, 2]; @@ -657,12 +689,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_int() { assert_eq!(relocatable!(1, 2) + &Felt::new(4), Ok(relocatable!(1, 6))); assert_eq!(relocatable!(3, 2) + &Felt::zero(), Ok(relocatable!(3, 2))); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_int_mod_offset_exceeded_error() { assert_eq!( relocatable!(0, 0) + &(Felt::new(usize::MAX) + 1_usize), @@ -674,6 +708,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_i32() { let reloc = relocatable!(1, 5); @@ -692,6 +727,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mayberelocatable_try_into_reloctable() { let address = mayberelocatable!(1, 2); assert_eq!(Ok(relocatable!(1, 2)), address.try_into()); @@ -702,6 +738,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_sub_rel_test() { let reloc = relocatable!(7, 6); assert_eq!(reloc - relocatable!(7, 5), Ok(1)); @@ -712,6 +749,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_rel_different_indexes() { let a = relocatable!(7, 6); let b = relocatable!(8, 6); @@ -719,6 +757,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_ok() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(2), @@ -743,6 +782,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_add_two_relocatable_error() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(1, 2), @@ -754,6 +794,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_maybe_mod_offset_exceeded_error() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(usize::MAX as i128 + 1), @@ -765,6 +806,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_relocatable_test() { assert_eq!( mayberelocatable!(1, 2).get_relocatable(), @@ -774,6 +816,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_display() { assert_eq!( format!("{}", Relocatable::from((1, 0))), @@ -782,6 +825,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn maybe_relocatable_relocatable_display() { assert_eq!( format!("{}", MaybeRelocatable::from((1, 0))), @@ -790,6 +834,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn maybe_relocatable_int_display() { assert_eq!( format!("{}", MaybeRelocatable::from(Felt::new(6))), diff --git a/src/utils.rs b/src/utils.rs index 2193905a2f..301a1b6e93 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use crate::types::relocatable::Relocatable; use felt::Felt; use lazy_static::lazy_static; @@ -20,7 +22,7 @@ lazy_static! { #[macro_export] macro_rules! any_box { ($val : expr) => { - Box::new($val) as Box + $crate::stdlib::boxed::Box::new($val) as $crate::stdlib::boxed::Box }; } @@ -144,9 +146,9 @@ pub mod test_utils { let mut res = $mem.insert(k, v); while matches!(res, Err(MemoryError::UnallocatedSegment(_, _))) { if $si < 0 { - $mem.temp_data.push(Vec::new()) + $mem.temp_data.push($crate::stdlib::vec::Vec::new()) } else { - $mem.data.push(Vec::new()); + $mem.data.push($crate::stdlib::vec::Vec::new()); } res = $mem.insert(k, v); } @@ -156,9 +158,9 @@ pub mod test_utils { let mut res = $mem.insert(k, v); while matches!(res, Err(MemoryError::UnallocatedSegment(_, _))) { if $si < 0 { - $mem.temp_data.push(Vec::new()) + $mem.temp_data.push($crate::stdlib::vec::Vec::new()) } else { - $mem.data.push(Vec::new()); + $mem.data.push($crate::stdlib::vec::Vec::new()); } res = $mem.insert(k, v); } @@ -203,7 +205,7 @@ pub mod test_utils { macro_rules! references { ($num: expr) => {{ - let mut references = HashMap::::new(); + let mut references = crate::stdlib::collections::HashMap::::new(); for i in 0..$num { references.insert(i as usize, HintReference::new_simple((i as i32 - $num))); } @@ -250,17 +252,17 @@ pub mod test_utils { Program { builtins: vec![$( $builtin_name ),*], prime: "0x800000000000011000000000000000000000000000000000000000000000001".to_string(), - data: Vec::new(), - constants: HashMap::new(), + data: crate::stdlib::vec::Vec::new(), + constants: crate::stdlib::collections::HashMap::new(), main: None, start: None, end: None, - hints: HashMap::new(), + hints: crate::stdlib::collections::HashMap::new(), reference_manager: ReferenceManager { - references: Vec::new(), + references: crate::stdlib::vec::Vec::new(), }, - identifiers: HashMap::new(), - error_message_attributes: Vec::new(), + identifiers: crate::stdlib::collections::HashMap::new(), + error_message_attributes: crate::stdlib::vec::Vec::new(), instruction_locations: None, } }; @@ -301,9 +303,9 @@ pub mod test_utils { { let ids_names = vec![$( $name ),*]; let references = references!(ids_names.len() as i32); - let mut ids_data = HashMap::::new(); + let mut ids_data = crate::stdlib::collections::HashMap::::new(); for (i, name) in ids_names.iter().enumerate() { - ids_data.insert(name.to_string(), references.get(&i).unwrap().clone()); + ids_data.insert(crate::stdlib::string::ToString::to_string(name), references.get(&i).unwrap().clone()); } ids_data } @@ -314,9 +316,9 @@ pub mod test_utils { macro_rules! non_continuous_ids_data { ( $( ($name: expr, $offset:expr) ),* ) => { { - let mut ids_data = HashMap::::new(); + let mut ids_data = crate::stdlib::collections::HashMap::::new(); $( - ids_data.insert(String::from($name), HintReference::new_simple($offset)); + ids_data.insert(crate::stdlib::string::String::from($name), HintReference::new_simple($offset)); )* ids_data } @@ -365,23 +367,29 @@ pub mod test_utils { hint_processor.execute_hint(&mut $vm, $exec_scopes, &any_box!(hint_data), $constants) }}; ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr) => {{ - let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); + let hint_data = HintProcessorData::new_default( + crate::stdlib::string::ToString::to_string($hint_code), + $ids_data, + ); let mut hint_processor = BuiltinHintProcessor::new_empty(); hint_processor.execute_hint( &mut $vm, $exec_scopes, &any_box!(hint_data), - &HashMap::new(), + &crate::stdlib::collections::HashMap::new(), ) }}; ($vm:expr, $ids_data:expr, $hint_code:expr) => {{ - let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); + let hint_data = HintProcessorData::new_default( + crate::stdlib::string::ToString::to_string($hint_code), + $ids_data, + ); let mut hint_processor = BuiltinHintProcessor::new_empty(); hint_processor.execute_hint( &mut $vm, exec_scopes_ref!(), &any_box!(hint_data), - &HashMap::new(), + &crate::stdlib::collections::HashMap::new(), ) }}; } @@ -465,13 +473,13 @@ pub mod test_utils { )* let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) }; ($exec_scopes:expr, $tracker_num:expr) => { let tracker = DictTracker::new_empty(relocatable!($tracker_num, 0)); let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) }; } @@ -485,13 +493,13 @@ pub mod test_utils { )* let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) }; ($exec_scopes:expr, $tracker_num:expr,$default:expr) => { let tracker = DictTracker::new_default_dict(relocatable!($tracker_num, 0), &MaybeRelocatable::from($default), None); let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); - $exec_scopes.insert_value("dict_manager", Rc::new(RefCell::new(dict_manager))) + $exec_scopes.insert_value("dict_manager", crate::stdlib::rc::Rc::new(core::cell::RefCell::new(dict_manager))) }; } pub(crate) use dict_manager_default; @@ -513,7 +521,7 @@ pub mod test_utils { } pub(crate) use vec_data_inner; - pub fn check_scope_value( + pub fn check_scope_value( scopes: &ExecutionScopes, name: &str, value: T, @@ -525,6 +533,7 @@ pub mod test_utils { #[cfg(test)] mod test { + use crate::stdlib::{cell::RefCell, collections::HashMap, rc::Rc, string::String, vec::Vec}; use crate::{ hint_processor::{ builtin_hint_processor::{ @@ -543,11 +552,14 @@ mod test { }; use felt::Felt; use num_traits::One; - use std::{any::Any, cell::RefCell, collections::HashMap, rc::Rc}; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; use super::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn memory_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -570,6 +582,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -593,6 +606,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_address_macro_test() { let mut memory = Memory::new(); for _ in 0..2 { @@ -617,6 +631,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_run_context() { let mut vm = vm!(); run_context!(vm, 2, 6, 10); @@ -627,6 +642,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assert_trace() { let trace = vec![ TraceEntry { @@ -683,6 +699,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_non_continuous_ids_data() { let ids_data_macro = non_continuous_ids_data![("a", -2), ("", -6)]; let ids_data_verbose = HashMap::from([ @@ -693,6 +710,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_hint_alloc() { let hint_code = "memory[ap] = segments.add()"; let mut vm = vm!(); @@ -703,6 +721,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_scope_test_pass() { let mut exec_scopes = ExecutionScopes::new(); exec_scopes.assign_or_update_variable("a", any_box!(String::from("Hello"))); @@ -748,6 +767,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn scope_macro_test() { let scope_from_macro = scope![("a", Felt::one())]; let mut scope_verbose = ExecutionScopes::new(); @@ -761,6 +781,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_dictionary_pass() { let mut tracker = DictTracker::new_empty(relocatable!(2, 0)); tracker.insert_value( @@ -796,6 +817,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_dict_ptr_pass() { let tracker = DictTracker::new_empty(relocatable!(2, 0)); let mut dict_manager = DictManager::new(); @@ -823,6 +845,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_macro() { let tracker = DictTracker::new_empty(relocatable!(2, 0)); let mut dict_manager = DictManager::new(); @@ -836,6 +859,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn dict_manager_default_macro() { let tracker = DictTracker::new_default_dict( relocatable!(2, 0), @@ -853,6 +877,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn data_vec_test() { let data = vec_data!((1), ((2, 2)), (("49128305", 10)), (("3b6f00a9", 16))); assert_eq!(data[0], mayberelocatable!(1)); @@ -861,6 +886,7 @@ mod test { assert_eq!(data[3], mayberelocatable!(997130409)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_relocatable_to_indexes_test() { let reloc_1 = relocatable!(1, 5); let reloc_2 = relocatable!(0, 5); @@ -871,6 +897,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro() { let program = Program { builtins: Vec::new(), @@ -893,6 +920,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro_with_builtin() { let program = Program { builtins: vec![BuiltinName::range_check], @@ -915,6 +943,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn program_macro_custom_definition() { let program = Program { builtins: vec![BuiltinName::range_check], diff --git a/src/vm/context/run_context.rs b/src/vm/context/run_context.rs index 7a5839d634..5a49f2a2ea 100644 --- a/src/vm/context/run_context.rs +++ b/src/vm/context/run_context.rs @@ -101,13 +101,18 @@ impl RunContext { mod tests { use super::*; use crate::relocatable; + use crate::stdlib::string::ToString; use crate::types::instruction::{ApUpdate, FpUpdate, Opcode, PcUpdate, Res}; use crate::utils::test_utils::mayberelocatable; use crate::vm::errors::memory_errors::MemoryError; use assert_matches::assert_matches; use felt::Felt; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_dst_addr_for_ap_register() { let instruction = Instruction { off0: 1, @@ -136,6 +141,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_dst_addr_for_fp_register() { let instruction = Instruction { off0: 1, @@ -165,6 +171,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op0_addr_for_ap_register() { let instruction = Instruction { off0: 1, @@ -193,6 +200,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op0_addr_for_fp_register() { let instruction = Instruction { off0: 1, @@ -221,6 +229,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_fp_op1_addr() { let instruction = Instruction { off0: 1, @@ -249,6 +258,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_ap_op1_addr() { let instruction = Instruction { off0: 1, @@ -277,6 +287,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_imm_op1_addr_correct_off2() { let instruction = Instruction { off0: 1, @@ -305,6 +316,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_imm_op1_addr_incorrect_off2() { let instruction = Instruction { off0: 1, @@ -336,6 +348,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_op0_op1_addr_with_op0() { let instruction = Instruction { off0: 1, @@ -366,6 +379,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_with_no_relocatable_address() { let instruction = Instruction { off0: 1, @@ -398,6 +412,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_op1_addr_for_op0_op1_addr_without_op0() { let instruction = Instruction { off0: 1, diff --git a/src/vm/decoding/decoder.rs b/src/vm/decoding/decoder.rs index 106e7e7a0f..880b478996 100644 --- a/src/vm/decoding/decoder.rs +++ b/src/vm/decoding/decoder.rs @@ -146,9 +146,14 @@ fn decode_offset(offset: i64) -> isize { #[cfg(test)] mod decoder_test { use super::*; + use crate::stdlib::string::ToString; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_op1_reg() { let error = decode_instruction(0x294F800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidOp1Reg(3))); @@ -159,6 +164,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_pc_update() { let error = decode_instruction(0x29A8800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidPcUpdate(3))); @@ -166,6 +172,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_res_logic() { let error = decode_instruction(0x2968800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidRes(3))); @@ -173,6 +180,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_opcode() { let error = decode_instruction(0x3948800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidOpcode(3))); @@ -180,6 +188,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn invalid_ap_update() { let error = decode_instruction(0x2D48800080008000, None); assert_matches!(error, Err(VirtualMachineError::InvalidApUpdate(3))); @@ -187,6 +196,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_no_immediate_given() { assert_matches!( decode_instruction(0x14A7800080008000, None), @@ -195,6 +205,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_call_add_jmp_add_imm_fp_fp() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -213,6 +224,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_ret_add1_jmp_rel_mul_fp_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -231,6 +243,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_assrt_add_jnz_mul_ap_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -249,6 +262,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_assrt_add2_jnz_uncon_op0_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -267,6 +281,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_flags_nop_regu_regu_op1_op0_ap_ap() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -285,6 +300,7 @@ mod decoder_test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_offset_negative() { // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 diff --git a/src/vm/errors/cairo_run_errors.rs b/src/vm/errors/cairo_run_errors.rs index 3810343411..7684b29f2f 100644 --- a/src/vm/errors/cairo_run_errors.rs +++ b/src/vm/errors/cairo_run_errors.rs @@ -1,10 +1,14 @@ +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + use super::memory_errors::MemoryError; use super::vm_exception::VmException; use crate::types::errors::program_errors::ProgramError; use crate::vm::errors::{ runner_errors::RunnerError, trace_errors::TraceError, vm_errors::VirtualMachineError, }; -use thiserror::Error; #[derive(Debug, Error)] pub enum CairoRunError { diff --git a/src/vm/errors/exec_scope_errors.rs b/src/vm/errors/exec_scope_errors.rs index ec422dd32d..92e794a022 100644 --- a/src/vm/errors/exec_scope_errors.rs +++ b/src/vm/errors/exec_scope_errors.rs @@ -1,4 +1,7 @@ +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; #[derive(Eq, Hash, PartialEq, Debug, Error)] pub enum ExecScopeError { diff --git a/src/vm/errors/hint_errors.rs b/src/vm/errors/hint_errors.rs index 5479a8944f..e2ce4ec78d 100644 --- a/src/vm/errors/hint_errors.rs +++ b/src/vm/errors/hint_errors.rs @@ -1,6 +1,12 @@ +use crate::stdlib::prelude::*; + +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + use felt::Felt; use num_bigint::{BigInt, BigUint}; -use thiserror::Error; use crate::types::{ errors::math_errors::MathError, diff --git a/src/vm/errors/memory_errors.rs b/src/vm/errors/memory_errors.rs index afe99d6867..a6cf4eeb4f 100644 --- a/src/vm/errors/memory_errors.rs +++ b/src/vm/errors/memory_errors.rs @@ -1,5 +1,11 @@ -use felt::Felt; +use crate::stdlib::prelude::*; + +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + +use felt::Felt; use crate::types::{ errors::math_errors::MathError, diff --git a/src/vm/errors/runner_errors.rs b/src/vm/errors/runner_errors.rs index 2fe4bc0558..518fe75f14 100644 --- a/src/vm/errors/runner_errors.rs +++ b/src/vm/errors/runner_errors.rs @@ -1,4 +1,9 @@ -use std::collections::HashSet; +use crate::stdlib::{collections::HashSet, prelude::*}; + +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; use super::memory_errors::MemoryError; use crate::types::{ @@ -6,7 +11,6 @@ use crate::types::{ relocatable::{MaybeRelocatable, Relocatable}, }; use felt::Felt; -use thiserror::Error; #[derive(Debug, PartialEq, Error)] pub enum RunnerError { @@ -16,8 +20,6 @@ pub enum RunnerError { NoProgBase, #[error("Missing main()")] MissingMain, - #[error("Failed to write program output")] - WriteFail, #[error("Found None PC during VM initialization")] NoPC, #[error("Found None AP during VM initialization")] diff --git a/src/vm/errors/trace_errors.rs b/src/vm/errors/trace_errors.rs index 2f63144512..dce825e20d 100644 --- a/src/vm/errors/trace_errors.rs +++ b/src/vm/errors/trace_errors.rs @@ -1,5 +1,9 @@ -use crate::vm::errors::memory_errors::MemoryError; +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + +use crate::vm::errors::memory_errors::MemoryError; #[derive(Debug, PartialEq, Error)] pub enum TraceError { diff --git a/src/vm/errors/vm_errors.rs b/src/vm/errors/vm_errors.rs index 1f099b4f93..2ee743d006 100644 --- a/src/vm/errors/vm_errors.rs +++ b/src/vm/errors/vm_errors.rs @@ -1,3 +1,10 @@ +use crate::stdlib::prelude::*; + +#[cfg(feature = "std")] +use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; + use crate::{ types::{ errors::math_errors::MathError, @@ -9,8 +16,6 @@ use crate::{ }, }; use felt::Felt; -use std::error::Error; -use thiserror::Error; #[derive(Debug, Error)] pub enum VirtualMachineError { @@ -110,6 +115,8 @@ pub enum VirtualMachineError { MissingAccessedAddresses, #[error(transparent)] Math(#[from] MathError), + #[error("Failed to write the output builtin content")] + FailedToWriteOutput, #[error(transparent)] - Other(Box), + Other(anyhow::Error), } diff --git a/src/vm/errors/vm_exception.rs b/src/vm/errors/vm_exception.rs index 070214f72f..35145deab0 100644 --- a/src/vm/errors/vm_exception.rs +++ b/src/vm/errors/vm_exception.rs @@ -1,11 +1,13 @@ -use std::{ +use crate::stdlib::{ fmt::{self, Display}, - fs::File, - io::{BufReader, Read}, - path::Path, + prelude::*, + str, }; +#[cfg(feature = "std")] use thiserror::Error; +#[cfg(all(not(feature = "std"), feature = "alloc"))] +use thiserror_no_std::Error; use crate::{ hint_processor::{ @@ -229,7 +231,7 @@ impl Display for VmException { impl Location { /// Prints the location with the passed message. - pub fn to_string(&self, message: &String) -> String { + pub fn to_string(&self, message: &str) -> String { let msg_prefix = if message.is_empty() { "" } else { ": " }; format!( "{}:{}:{}{}{}", @@ -237,20 +239,26 @@ impl Location { ) } - pub fn to_string_with_content(&self, message: &String) -> String { + #[cfg(all(not(feature = "std"), feature = "alloc"))] + pub fn to_string_with_content(&self, message: &str) -> String { + self.to_string(message) + } + + #[cfg(feature = "std")] + pub fn to_string_with_content(&self, message: &str) -> String { let mut string = self.to_string(message); - let input_file_path = Path::new(&self.input_file.filename); - if let Ok(file) = File::open(input_file_path) { - let mut reader = BufReader::new(file); - string.push_str(&format!("\n{}", self.get_location_marks(&mut reader))); + let input_file_path = std::path::Path::new(&self.input_file.filename); + if let Ok(file_content) = std::fs::read(input_file_path) { + string.push_str(&format!("\n{}", self.get_location_marks(&file_content))); } string } - pub fn get_location_marks(&self, file_contents: &mut impl Read) -> String { + pub fn get_location_marks(&self, file_contents: &[u8]) -> String { let mut contents = String::new(); - // If this read fails, the string will be left empty, so we can ignore the result - let _ = file_contents.read_to_string(&mut contents); + if let Ok(content) = str::from_utf8(file_contents) { + contents.push_str(content); + } let split_lines: Vec<&str> = contents.split('\n').collect(); if !(0 < self.start_line && ((self.start_line - 1) as usize) < split_lines.len()) { return String::new(); @@ -275,8 +283,9 @@ impl Location { } #[cfg(test)] mod test { + use crate::stdlib::{boxed::Box, collections::HashMap}; use assert_matches::assert_matches; - use std::collections::HashMap; + #[cfg(feature = "std")] use std::path::Path; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; @@ -287,8 +296,12 @@ mod test { use crate::types::relocatable::Relocatable; use crate::utils::test_utils::*; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + use super::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_vm_exception_from_vm_error() { let pc = 0; let location = Location { @@ -321,6 +334,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_no_message() { let location = Location { end_line: 2, @@ -340,6 +354,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_message() { let location = Location { end_line: 2, @@ -359,6 +374,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_location_no_attributes() { let vm_excep = VmException { pc: 2, @@ -383,6 +399,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_location_with_attributes() { let vm_excep = VmException { pc: 2, @@ -407,6 +424,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_attributes_no_parent() { let location = Location { end_line: 2, @@ -441,6 +459,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn vm_exception_display_instruction_no_attributes_with_parent() { let location = Location { end_line: 2, @@ -484,6 +503,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_error_attr_value_some() { let attributes = vec![Attribute { name: String::from("Error message"), @@ -502,6 +522,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_error_attr_value_none() { let attributes = vec![Attribute { name: String::from("Error message"), @@ -517,6 +538,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_some() { let location = Location { end_line: 2, @@ -539,6 +561,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_none() { let location = Location { end_line: 2, @@ -561,6 +584,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_location_some_hint_index() { let location_a = Location { end_line: 2, @@ -597,12 +621,17 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_bad_dict_update() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_dict_update.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/bad_dict_update.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); + #[cfg(feature = "std")] + let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n dict_update{dict_ptr=my_dict}(key=2, prev_value=3, new_value=4);\n ^*************************************************************^\n"); + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n"); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -612,17 +641,35 @@ mod test { assert!(cairo_runner .run_until_pc(end, &mut vm, &mut hint_processor) .is_err()); - let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_dict_update.cairo:10:5: (pc=0:34)\n dict_update{dict_ptr=my_dict}(key=2, prev_value=3, new_value=4);\n ^*************************************************************^\n"); assert_eq!(get_traceback(&vm, &cairo_runner), Some(expected_traceback)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_bad_usort() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_usort.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); + #[cfg(feature = "std")] + let expected_traceback = r"Cairo traceback (most recent call last): +cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) + let (output_len, output, multiplicities) = usort(input_len=3, input=input_array); + ^***********************************^ +cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) + verify_usort{output=output}( + ^**************************^ +cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) + verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value); + ^*******************************************************************************************^ +"; + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_traceback = r"Cairo traceback (most recent call last): +cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) +cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) +cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) +"; let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -632,11 +679,14 @@ mod test { assert!(cairo_runner .run_until_pc(end, &mut vm, &mut hint_processor) .is_err()); - let expected_traceback = String::from("Cairo traceback (most recent call last):\ncairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97)\n let (output_len, output, multiplicities) = usort(input_len=3, input=input_array);\n ^***********************************^\ncairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30)\n verify_usort{output=output}(\n ^**************************^\ncairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60)\n verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value);\n ^*******************************************************************************************^\n"); - assert_eq!(get_traceback(&vm, &cairo_runner), Some(expected_traceback)); + assert_eq!( + get_traceback(&vm, &cairo_runner), + Some(expected_traceback.to_string()) + ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents_no_contents() { let location = Location { end_line: 2, @@ -656,6 +706,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents() { let location = Location { end_line: 5, @@ -668,13 +719,20 @@ mod test { start_col: 1, }; let message = String::from("Error at pc=0:75:"); + + #[cfg(feature = "std")] + let expected_message = "cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:\nfunc usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^"; + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_message = "cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:"; + assert_eq!( location.to_string_with_content(&message), - String::from("cairo_programs/bad_programs/bad_usort.cairo:5:1: Error at pc=0:75:\nfunc usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^") + expected_message.to_string() ) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_to_string_with_contents_no_file() { let location = Location { end_line: 5, @@ -696,6 +754,7 @@ mod test { } #[test] + #[cfg(feature = "std")] fn location_get_location_marks() { let location = Location { end_line: 5, @@ -708,15 +767,15 @@ mod test { start_col: 1, }; let input_file_path = Path::new(&location.input_file.filename); - let file = File::open(input_file_path).expect("Failed to open file"); - let mut reader = BufReader::new(file); + let file_content = std::fs::read(input_file_path).expect("Failed to open file"); assert_eq!( - location.get_location_marks(&mut reader), + location.get_location_marks(&file_content), String::from("func usort{range_check_ptr}(input_len: felt, input: felt*) -> (\n^") ) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn location_get_location_marks_empty_file() { let location = Location { end_line: 5, @@ -728,12 +787,14 @@ mod test { start_line: 5, start_col: 1, }; - let mut reader: &[u8] = &[]; - assert_eq!(location.get_location_marks(&mut reader), String::from("")) + let reader: &[u8] = &[]; + assert_eq!(location.get_location_marks(reader), String::from("")) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_bad_range_check_and_check_error_displayed() { + #[cfg(feature = "std")] let expected_error_string = r#"Error message: Failed range-check cairo_programs/bad_programs/bad_range_check.cairo:5:9: Error at pc=0:0: An ASSERT_EQ instruction failed: 4 != 5. @@ -753,11 +814,21 @@ cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) check_range(num - 1); ^******************^ "#; - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_range_check.json"), + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_error_string = r#"Error message: Failed range-check +cairo_programs/bad_programs/bad_range_check.cairo:5:9: Error at pc=0:0: +An ASSERT_EQ instruction failed: 4 != 5. +Cairo traceback (most recent call last): +cairo_programs/bad_programs/bad_range_check.cairo:23:5: (pc=0:29) +cairo_programs/bad_programs/bad_range_check.cairo:19:12: (pc=0:21) +cairo_programs/bad_programs/bad_range_check.cairo:19:33: (pc=0:17) +cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) +"#; + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/bad_range_check.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -772,7 +843,9 @@ cairo_programs/bad_programs/bad_range_check.cairo:11:5: (pc=0:6) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_bad_usort_and_check_error_displayed() { + #[cfg(feature = "std")] let expected_error_string = r#"cairo_programs/bad_programs/bad_usort.cairo:79:5: Error at pc=0:75: Got an exception while executing a hint: unexpected verify multiplicity fail: positions length != 0 %{ assert len(positions) == 0 %} @@ -788,11 +861,19 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) verify_multiplicity(multiplicity=multiplicity, input_len=input_len, input=input, value=value); ^*******************************************************************************************^ "#; - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_usort.json"), + #[cfg(all(not(feature = "std"), feature = "alloc"))] + let expected_error_string = r#"cairo_programs/bad_programs/bad_usort.cairo:79:5: Error at pc=0:75: +Got an exception while executing a hint: unexpected verify multiplicity fail: positions length != 0 +Cairo traceback (most recent call last): +cairo_programs/bad_programs/bad_usort.cairo:91:48: (pc=0:97) +cairo_programs/bad_programs/bad_usort.cairo:36:5: (pc=0:30) +cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) +"#; + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -807,12 +888,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_value_from_simple_reference_ap_based() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); // This program uses a tempvar inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -825,12 +907,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn substitute_error_message_references_ap_based() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); // This program uses a tempvar inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -846,12 +929,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_value_from_simple_reference_complex() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_struct.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); // This program uses a struct inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); @@ -864,12 +948,13 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn substitute_error_message_references_complex() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_attr_struct.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); // This program uses a struct inside an error attribute // This reference should be rejected when substituting the error attribute references let runner = cairo_runner!(program); diff --git a/src/vm/hooks.rs b/src/vm/hooks.rs index dab0c4db39..883e1241ff 100644 --- a/src/vm/hooks.rs +++ b/src/vm/hooks.rs @@ -9,7 +9,7 @@ //! - pre_step_instruction, executed before each instruction_step in [step](VirtualMachine::step) //! - post_step_instruction, executed after each instruction_step in [step](VirtualMachine::step) -use std::{any::Any, collections::HashMap, sync::Arc}; +use crate::stdlib::{any::Any, collections::HashMap, prelude::*, sync::Arc}; use felt::Felt; @@ -124,8 +124,6 @@ impl VirtualMachine { #[cfg(test)] mod tests { - use std::path::Path; - use super::*; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -135,8 +133,11 @@ mod tests { #[test] fn empty_hooks() { - let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/sqrt.json"), + Some("main"), + ) + .expect("Call to `Program::from_file()` failed."); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program); @@ -151,8 +152,11 @@ mod tests { #[test] fn hook_failure() { - let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/sqrt.json"), + Some("main"), + ) + .expect("Call to `Program::from_file()` failed."); fn before_first_step_hook( _vm: &mut VirtualMachine, @@ -218,8 +222,11 @@ mod tests { #[test] fn hook_success() { - let program = Program::from_file(Path::new("cairo_programs/sqrt.json"), Some("main")) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/sqrt.json"), + Some("main"), + ) + .expect("Call to `Program::from_file()` failed."); fn before_first_step_hook( _vm: &mut VirtualMachine, diff --git a/src/vm/runners/builtin_runner/bitwise.rs b/src/vm/runners/builtin_runner/bitwise.rs index d72b6e4b7e..311bfb76b8 100644 --- a/src/vm/runners/builtin_runner/bitwise.rs +++ b/src/vm/runners/builtin_runner/bitwise.rs @@ -1,3 +1,4 @@ +use crate::stdlib::vec::Vec; use crate::{ math_utils::safe_div_usize, types::{ @@ -229,17 +230,22 @@ mod tests { use super::*; use crate::relocatable; use crate::serde::deserialize_program::BuiltinName; + use crate::stdlib::collections::HashMap; use crate::vm::errors::memory_errors::MemoryError; + use crate::vm::runners::builtin_runner::BuiltinRunner; + use crate::vm::vm_core::VirtualMachine; use crate::vm::vm_memory::memory::Memory; - use crate::vm::{runners::builtin_runner::BuiltinRunner, vm_core::VirtualMachine}; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, utils::test_utils::*, vm::runners::cairo_runner::CairoRunner, }; use felt::Felt; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -258,6 +264,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -281,6 +288,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -308,6 +316,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), false); @@ -331,6 +340,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -354,6 +364,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true).into(); @@ -400,6 +411,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); @@ -443,6 +455,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_and() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 7), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -451,6 +464,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_xor() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 8), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -459,6 +473,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_valid_or() { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 9), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -467,6 +482,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_incorrect_offset() { let memory = memory![((0, 3), 10), ((0, 4), 12), ((0, 5), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -475,6 +491,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_for_preset_memory_no_values_to_operate() { let memory = memory![((0, 5), 12), ((0, 7), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -483,6 +500,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -490,6 +508,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -504,6 +523,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -516,6 +536,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -536,6 +557,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -550,6 +572,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -562,6 +585,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -574,6 +598,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_a() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -583,6 +608,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_b() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -592,6 +618,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_c() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), diff --git a/src/vm/runners/builtin_runner/ec_op.rs b/src/vm/runners/builtin_runner/ec_op.rs index c4105e14e5..5e7322c696 100644 --- a/src/vm/runners/builtin_runner/ec_op.rs +++ b/src/vm/runners/builtin_runner/ec_op.rs @@ -1,4 +1,4 @@ -use std::borrow::Cow; +use crate::stdlib::{borrow::Cow, prelude::*}; use crate::math_utils::{ec_add, ec_double, safe_div_usize}; use crate::types::instance_definitions::ec_op_instance_def::{ @@ -326,11 +326,12 @@ mod tests { use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; use crate::serde::deserialize_program::BuiltinName; + use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::{test_utils::*, CAIRO_PRIME}; - use crate::vm::errors::cairo_run_errors::CairoRunError; use crate::vm::errors::vm_errors::VirtualMachineError; use crate::vm::runners::cairo_runner::CairoRunner; + use crate::vm::security::verify_secure_runner; use crate::vm::vm_memory::memory::Memory; use crate::vm::{ errors::{memory_errors::MemoryError, runner_errors::RunnerError}, @@ -338,11 +339,13 @@ mod tests { vm_core::VirtualMachine, }; use felt::felt_str; - use std::collections::HashMap; - use std::path::Path; use EcOpBuiltinRunner; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -353,6 +356,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -376,6 +380,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -403,6 +408,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), false); @@ -426,6 +432,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -449,6 +456,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true).into(); @@ -493,6 +501,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true); @@ -536,6 +545,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_on_curve_a() { let x = felt_str!( "874739451078007766457464989774322083649278607533249481151382481072868806602" @@ -551,6 +561,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_on_curve_b() { let x = felt_str!( "3139037544796708144595053687182055617920475701120786241351436619796497072089" @@ -566,6 +577,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_not_on_curve_a() { let x = felt_str!( "874739454078007766457464989774322083649278607533249481151382481072868806602" @@ -581,6 +593,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn point_is_not_on_curve_b() { let x = felt_str!( "3139037544756708144595053687182055617927475701120786241351436619796497072089" @@ -596,6 +609,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_ec_op_impl_valid_a() { let partial_sum = ( felt_str!( @@ -633,6 +647,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_ec_op_impl_valid_b() { let partial_sum = ( felt_str!( @@ -670,6 +685,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] #[allow(deprecated)] fn compute_ec_op_invalid_same_x_coordinate() { let partial_sum = (Felt::one(), Felt::new(9)); @@ -699,6 +715,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Data taken from this program execution: %builtins output ec_op from starkware.cairo.common.cairo_builtins import EcOpBuiltin @@ -766,6 +783,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_unfilled_input_cells() { let memory = memory![ ( @@ -805,6 +823,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_addr_not_an_output_cell() { let memory = memory![ ( @@ -851,6 +870,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_for_preset_memory_non_integer_input() { let memory = memory![ ( @@ -895,6 +915,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -902,6 +923,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -914,6 +936,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -924,6 +947,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -942,6 +966,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -954,6 +979,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -964,6 +990,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -974,6 +1001,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stackincluded_test() { let ec_op_builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -981,52 +1009,82 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_notincluded_test() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), false); assert_eq!(ec_op_builtin.initial_stack(), Vec::new()) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn catch_point_same_x() { - let program = Path::new("cairo_programs/bad_programs/ec_op_same_x.json"); - let cairo_run_config = crate::cairo_run::CairoRunConfig { - layout: "all", - ..crate::cairo_run::CairoRunConfig::default() - }; - let result = crate::cairo_run::cairo_run( - program, - &cairo_run_config, - &mut BuiltinHintProcessor::new_empty(), - ); + let program = include_bytes!("../../../../cairo_programs/bad_programs/ec_op_same_x.json"); + let mut cairo_runner = CairoRunner::new( + &Program::from_bytes(program, Some("main")).unwrap(), + "all", + false, + ) + .unwrap(); + let mut vm = VirtualMachine::new(false); + let end = cairo_runner.initialize(&mut vm).unwrap(); + + let hint_executor = &mut BuiltinHintProcessor::new_empty(); + + cairo_runner + .run_until_pc(end, &mut vm, hint_executor) + .unwrap(); + cairo_runner + .end_run(false, false, &mut vm, hint_executor) + .unwrap(); + + vm.verify_auto_deductions().unwrap(); + cairo_runner.read_return_values(&mut vm).unwrap(); + let result = verify_secure_runner(&cairo_runner, true, &mut vm); + assert!(result.is_err()); // We need to check this way because CairoRunError doens't implement PartialEq match result { - Err(CairoRunError::VirtualMachine(VirtualMachineError::RunnerError( - RunnerError::EcOpSameXCoordinate(_), - ))) => {} + Err(VirtualMachineError::RunnerError(RunnerError::EcOpSameXCoordinate(_))) => {} Err(_) => panic!("Wrong error returned, expected RunnerError::EcOpSameXCoordinate"), Ok(_) => panic!("Expected run to fail"), } } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn catch_point_not_in_curve() { - let program = Path::new("cairo_programs/bad_programs/ec_op_not_in_curve.json"); - let cairo_run_config = crate::cairo_run::CairoRunConfig { - layout: "all", - ..crate::cairo_run::CairoRunConfig::default() - }; - let result = crate::cairo_run::cairo_run( - program, - &cairo_run_config, - &mut BuiltinHintProcessor::new_empty(), - ); + let program = + include_bytes!("../../../../cairo_programs/bad_programs/ec_op_not_in_curve.json"); + + let mut cairo_runner = CairoRunner::new( + &Program::from_bytes(program, Some("main")).unwrap(), + "all", + false, + ) + .unwrap(); + let mut vm = VirtualMachine::new(false); + let end = cairo_runner.initialize(&mut vm).unwrap(); + + let hint_proccesor = &mut BuiltinHintProcessor::new_empty(); + cairo_runner + .run_until_pc(end, &mut vm, hint_proccesor) + .unwrap(); + + cairo_runner + .end_run(false, false, &mut vm, hint_proccesor) + .unwrap(); + + vm.verify_auto_deductions().unwrap(); + + cairo_runner.read_return_values(&mut vm).unwrap(); + + let result = verify_secure_runner(&cairo_runner, true, &mut vm); + assert!(result.is_err()); + // We need to check this way because CairoRunError doens't implement PartialEq match result { - Err(CairoRunError::VirtualMachine(VirtualMachineError::RunnerError( - RunnerError::PointNotOnCurve(_), - ))) => {} + Err(VirtualMachineError::RunnerError(RunnerError::PointNotOnCurve(_))) => {} Err(_) => panic!("Wrong error returned, expected RunnerError::EcOpSameXCoordinate"), Ok(_) => panic!("Expected run to fail"), } diff --git a/src/vm/runners/builtin_runner/hash.rs b/src/vm/runners/builtin_runner/hash.rs index 8afd9cd200..89a40f6086 100644 --- a/src/vm/runners/builtin_runner/hash.rs +++ b/src/vm/runners/builtin_runner/hash.rs @@ -1,4 +1,4 @@ -use std::cell::RefCell; +use crate::stdlib::{cell::RefCell, prelude::*}; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::pedersen_instance_def::{ @@ -216,6 +216,7 @@ mod tests { use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; use crate::serde::deserialize_program::BuiltinName; + use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::test_utils::*; use crate::vm::runners::cairo_runner::CairoRunner; @@ -225,9 +226,12 @@ mod tests { vm_core::VirtualMachine, }; use felt::felt_str; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = HashBuiltinRunner::new(10, true); @@ -238,6 +242,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -261,6 +266,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -288,6 +294,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_not_included() { let mut builtin = HashBuiltinRunner::new(10, false); @@ -311,6 +318,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = HashBuiltinRunner::new(10, true); @@ -334,6 +342,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = HashBuiltinRunner::new(10, true).into(); @@ -379,6 +388,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = HashBuiltinRunner::new(10, true); @@ -422,6 +432,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_valid() { let memory = memory![((0, 3), 32), ((0, 4), 72), ((0, 5), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -440,6 +451,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_incorrect_offset() { let memory = memory![((0, 4), 32), ((0, 5), 72), ((0, 6), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -448,6 +460,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_no_values_to_hash() { let memory = memory![((0, 4), 72), ((0, 5), 0)]; let builtin = HashBuiltinRunner::new(8, true); @@ -456,6 +469,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_for_preset_memory_already_computed() { let memory = memory![((0, 3), 32), ((0, 4), 72), ((0, 5), 0)]; let mut builtin = HashBuiltinRunner::new(8, true); @@ -465,6 +479,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = HashBuiltinRunner::new(256, true); @@ -472,6 +487,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let vm = vm!(); @@ -483,6 +499,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -492,6 +509,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -509,6 +527,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let vm = vm!(); @@ -520,6 +539,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); @@ -529,6 +549,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 39ee2ee19a..4fd7939132 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use crate::hint_processor::builtin_hint_processor::keccak_utils::left_pad_u64; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::keccak_instance_def::KeccakInstanceDef; @@ -248,6 +250,7 @@ mod tests { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; + use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::test_utils::*; use crate::vm::runners::cairo_runner::CairoRunner; @@ -257,10 +260,12 @@ mod tests { runners::builtin_runner::BuiltinRunner, vm_core::VirtualMachine, }; - use std::collections::HashMap; - use std::path::Path; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -272,6 +277,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -295,6 +301,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -321,6 +328,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_not_included() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), false); @@ -345,6 +353,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true); @@ -368,6 +377,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -375,8 +385,11 @@ mod tests { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![0]); - let program = - Program::from_file(Path::new("cairo_programs/_keccak.json"), Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../../cairo_programs/_keccak.json"), + Some("main"), + ) + .unwrap(); let mut cairo_runner = cairo_runner!(program, "all"); @@ -395,6 +408,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::new(10, vec![200; 8]), true).into(); @@ -406,6 +420,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); @@ -413,6 +428,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let vm = vm!(); @@ -424,6 +440,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let mut vm = vm!(); @@ -433,6 +450,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let mut vm = vm!(); @@ -450,6 +468,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -462,6 +481,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -472,6 +492,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin: BuiltinRunner = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true).into(); @@ -482,6 +503,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stackincluded_test() { let keccak_builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); assert_eq!( @@ -491,12 +513,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_notincluded_test() { let keccak_builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), false); assert_eq!(keccak_builtin.initial_stack(), Vec::new()) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_memory_valid() { let memory = memory![ ((0, 16), 43), @@ -532,6 +556,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_non_reloc_address_err() { let memory = memory![ ((0, 4), 32), @@ -546,6 +571,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_offset_lt_input_cell_length_none() { let memory = memory![((0, 4), 32)]; let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); @@ -554,6 +580,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_offset_first_addr_error() { let memory = memory![ ((0, 16), 43), @@ -587,6 +614,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_expected_integer() { let memory = memory![((0, 0), (1, 2))]; @@ -606,6 +634,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_get_memory_err() { let memory = memory![((0, 35), 0)]; @@ -617,6 +646,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_memory_int_larger_than_bits() { let memory = memory![ ((0, 16), 43), @@ -657,6 +687,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_result() { let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); diff --git a/src/vm/runners/builtin_runner/mod.rs b/src/vm/runners/builtin_runner/mod.rs index a149af402f..9940472a53 100644 --- a/src/vm/runners/builtin_runner/mod.rs +++ b/src/vm/runners/builtin_runner/mod.rs @@ -1,3 +1,4 @@ +use crate::stdlib::prelude::*; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use crate::vm::errors::memory_errors::{self, MemoryError}; use crate::vm::errors::runner_errors::RunnerError; @@ -452,7 +453,11 @@ mod tests { }; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -465,6 +470,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -475,6 +481,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -493,6 +500,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.clone().into(); @@ -500,6 +508,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.clone().into(); @@ -507,6 +516,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.clone().into(); @@ -514,6 +524,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.clone().into(); @@ -521,6 +532,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.clone().into(); @@ -528,6 +540,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_n_input_cells_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -535,6 +548,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.clone().into(); @@ -542,6 +556,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.clone().into(); @@ -549,6 +564,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.clone().into(); @@ -556,6 +572,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.clone().into(); @@ -563,6 +580,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.clone().into(); @@ -570,6 +588,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -577,6 +596,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_cells_per_instance_keccak() { let keccak = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let builtin: BuiltinRunner = keccak.clone().into(); @@ -584,6 +604,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_bitwise() { let bitwise = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::new(10), true); let builtin: BuiltinRunner = bitwise.into(); @@ -591,6 +612,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_hash() { let hash = HashBuiltinRunner::new(10, true); let builtin: BuiltinRunner = hash.into(); @@ -598,6 +620,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_range_check() { let range_check = RangeCheckBuiltinRunner::new(10, 10, true); let builtin: BuiltinRunner = range_check.into(); @@ -605,6 +628,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_ec_op() { let ec_op = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); let builtin: BuiltinRunner = ec_op.into(); @@ -612,6 +636,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_ecdsa() { let signature = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let builtin: BuiltinRunner = signature.into(); @@ -619,6 +644,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_name_output() { let output = OutputBuiltinRunner::new(true); let builtin: BuiltinRunner = output.into(); @@ -626,6 +652,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_bitwise_with_items() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::new(10), @@ -672,6 +699,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_ec_op_with_items() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true)); @@ -715,6 +743,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_hash_with_items() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(10, true)); @@ -758,6 +787,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_range_check_with_items() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(10, 12, true)); @@ -801,6 +831,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_keccak_with_items() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::new(10, vec![200; 8]), @@ -813,6 +844,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -822,6 +854,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); let vm = vm!(); @@ -829,6 +862,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(1, true)); let vm = vm!(); @@ -836,6 +870,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -846,6 +881,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -854,6 +890,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_keccak() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -864,6 +901,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -871,6 +909,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -878,6 +917,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(256, true)); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -885,6 +925,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true)); @@ -893,6 +934,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -903,6 +945,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_bitwise() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -912,6 +955,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_keccak_zero_case() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -921,6 +965,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_keccak_non_zero_case() { let builtin = BuiltinRunner::Keccak(KeccakBuiltinRunner::new( &KeccakInstanceDef::default(), @@ -930,30 +975,35 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_ec_op() { let builtin = BuiltinRunner::EcOp(EcOpBuiltinRunner::new(&EcOpInstanceDef::new(10), true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_hash() { let builtin = BuiltinRunner::Hash(HashBuiltinRunner::new(16, true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_range_check() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_diluted_check_units_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); assert_eq!(builtin.get_used_diluted_check_units(270, 7), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses_test() { let bitwise_builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -974,6 +1024,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_for_output() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -982,6 +1033,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_empty_memory() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -993,6 +1045,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_empty_offsets() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -1006,6 +1059,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_bitwise_missing_memory_cells_with_offsets() { let builtin = BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( &BitwiseInstanceDef::default(), @@ -1028,6 +1082,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_bitwise_missing_memory_cells() { let mut bitwise_builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -1055,6 +1110,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_hash_missing_memory_cells_with_offsets() { let builtin: BuiltinRunner = HashBuiltinRunner::new(8, true).into(); let mut vm = vm!(); @@ -1075,6 +1131,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_hash_missing_memory_cells() { let hash_builtin = HashBuiltinRunner::new(8, true); @@ -1093,6 +1150,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_missing_memory_cells_with_offsets() { let range_check_builtin = RangeCheckBuiltinRunner::new(8, 8, true); let builtin: BuiltinRunner = range_check_builtin.into(); @@ -1116,6 +1174,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_missing_memory_cells() { let builtin: BuiltinRunner = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(8, 8, true)); @@ -1132,6 +1191,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_range_check_empty() { let range_check_builtin = RangeCheckBuiltinRunner::new(8, 8, true); @@ -1145,6 +1205,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_checks_validate_auto_deductions() { let builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1167,6 +1228,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_empty() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1180,6 +1242,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_1_element() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1197,6 +1260,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_3_elements() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1215,6 +1279,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_missing_memory_cells_with_offsets() { let builtin: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -1237,6 +1302,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_security_ec_op_check_memory_gap() { let ec_op_builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -1269,6 +1335,7 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is a BitwiseBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_bitwise() { let builtin_runner: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1282,6 +1349,7 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is an EcOpBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_ec_op() { let builtin_runner: BuiltinRunner = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true).into(); @@ -1295,6 +1363,7 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is a HashBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_hash() { let builtin_runner: BuiltinRunner = HashBuiltinRunner::new(8, true).into(); let mut vm = vm!(); @@ -1307,6 +1376,7 @@ mod tests { /// Test that get_used_perm_range_check_units() returns zero when the /// builtin is an OutputBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_output() { let builtin_runner: BuiltinRunner = OutputBuiltinRunner::new(true).into(); let mut vm = vm!(); @@ -1319,6 +1389,7 @@ mod tests { /// Test that get_used_perm_range_check_units() calls the corresponding /// method when the builtin is a RangeCheckBuiltinRunner. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units_range_check() { let builtin_runner: BuiltinRunner = RangeCheckBuiltinRunner::new(8, 8, true).into(); let mut vm = vm!(); @@ -1329,6 +1400,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_ratio_tests() { let bitwise_builtin: BuiltinRunner = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(); @@ -1349,6 +1421,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn bitwise_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1359,6 +1432,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn ec_op_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1369,6 +1443,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn hash_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1378,6 +1453,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn output_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1386,6 +1462,7 @@ mod tests { assert_eq!(output_builtin.get_used_instances(&vm.segments), Ok(4)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn range_check_get_used_instances_test() { let mut vm = vm!(); vm.segments.segment_used_sizes = Some(vec![4]); @@ -1396,6 +1473,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn runners_final_stack() { let mut builtins = vec![ BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( @@ -1423,6 +1501,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn runners_set_stop_ptr() { let builtins = vec![ BuiltinRunner::Bitwise(BitwiseBuiltinRunner::new( diff --git a/src/vm/runners/builtin_runner/output.rs b/src/vm/runners/builtin_runner/output.rs index 618faa0f1a..131d23c4ee 100644 --- a/src/vm/runners/builtin_runner/output.rs +++ b/src/vm/runners/builtin_runner/output.rs @@ -1,3 +1,4 @@ +use crate::stdlib::prelude::*; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use crate::vm::errors::memory_errors::MemoryError; use crate::vm::errors::runner_errors::RunnerError; @@ -126,6 +127,7 @@ impl Default for OutputBuiltinRunner { mod tests { use super::*; use crate::relocatable; + use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory::Memory; use crate::{ utils::test_utils::*, @@ -134,9 +136,12 @@ mod tests { vm_core::VirtualMachine, }, }; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = OutputBuiltinRunner::new(true); @@ -147,6 +152,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = OutputBuiltinRunner::new(true); @@ -170,6 +176,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = OutputBuiltinRunner::new(true); @@ -197,6 +204,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = OutputBuiltinRunner::new(false); @@ -220,6 +228,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = OutputBuiltinRunner::new(true); @@ -243,6 +252,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = OutputBuiltinRunner::new(true).into(); @@ -257,6 +267,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = OutputBuiltinRunner::new(true); @@ -266,6 +277,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_output() { let mut builtin = OutputBuiltinRunner::new(true); let mut segments = MemorySegmentManager::new(); @@ -274,6 +286,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_output_with_base() { let mut builtin = OutputBuiltinRunner::new(true); builtin.base = 1; @@ -286,6 +299,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = OutputBuiltinRunner::new(true); @@ -293,6 +307,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -304,6 +319,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -313,6 +329,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -330,6 +347,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let vm = vm!(); @@ -341,6 +359,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -350,6 +369,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -359,6 +379,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_used_instances_missing_segments() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let memory_segment_manager = MemorySegmentManager::new(); @@ -370,6 +391,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_used_instances_valid() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut memory_segment_manager = MemorySegmentManager::new(); @@ -379,6 +401,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_deduce_memory_cell_output_builtin() { let builtin = BuiltinRunner::Output(OutputBuiltinRunner::new(true)); let mut vm = vm!(); @@ -401,6 +424,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_add_validation_rule() { let builtin = OutputBuiltinRunner::new(true); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/range_check.rs b/src/vm/runners/builtin_runner/range_check.rs index 2f3256eb02..4d748f9d77 100644 --- a/src/vm/runners/builtin_runner/range_check.rs +++ b/src/vm/runners/builtin_runner/range_check.rs @@ -1,3 +1,9 @@ +use crate::stdlib::{ + cmp::{max, min}, + ops::Shl, + prelude::*, +}; + use crate::{ math_utils::safe_div_usize, types::{ @@ -19,10 +25,6 @@ use crate::{ use felt::Felt; use num_integer::Integer; use num_traits::{One, ToPrimitive, Zero}; -use std::{ - cmp::{max, min}, - ops::Shl, -}; use super::RANGE_CHECK_BUILTIN_NAME; @@ -249,6 +251,7 @@ mod tests { use super::*; use crate::relocatable; use crate::serde::deserialize_program::BuiltinName; + use crate::stdlib::collections::HashMap; use crate::vm::vm_memory::memory::Memory; use crate::{ hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, @@ -259,9 +262,12 @@ mod tests { vm_core::VirtualMachine, }, }; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -272,6 +278,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -295,6 +302,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -322,6 +330,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_when_notincluded() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, false); @@ -345,6 +354,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -368,6 +378,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_test() { let builtin: BuiltinRunner = RangeCheckBuiltinRunner::new(10, 12, true).into(); @@ -413,6 +424,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units() { let builtin = RangeCheckBuiltinRunner::new(10, 12, true); @@ -456,6 +468,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_range_check() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -464,6 +477,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_range_check_with_base() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); builtin.base = 1; @@ -476,6 +490,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); @@ -483,6 +498,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let vm = vm!(); @@ -494,6 +510,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -503,6 +520,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -520,18 +538,21 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_base() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); assert_eq!(builtin.base(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_ratio() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); assert_eq!(builtin.ratio(), 8); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let vm = vm!(); @@ -543,6 +564,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -552,6 +574,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::RangeCheck(RangeCheckBuiltinRunner::new(256, 8, true)); let mut vm = vm!(); @@ -561,6 +584,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_a() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3), ((0, 3), 4)]; @@ -568,6 +592,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_b() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![ @@ -580,6 +605,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_usage_succesful_c() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = memory![ @@ -594,6 +620,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_check_empty_memory() { let builtin = RangeCheckBuiltinRunner::new(8, 8, true); let memory = Memory::new(); @@ -602,6 +629,7 @@ mod tests { /// Test that the method get_used_perm_range_check_units works as intended. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_perm_range_check_units() { let builtin_runner = RangeCheckBuiltinRunner::new(8, 8, true); let mut vm = vm!(); diff --git a/src/vm/runners/builtin_runner/signature.rs b/src/vm/runners/builtin_runner/signature.rs index 1095de4a93..b9c29f7c33 100644 --- a/src/vm/runners/builtin_runner/signature.rs +++ b/src/vm/runners/builtin_runner/signature.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{cell::RefCell, collections::HashMap, prelude::*, rc::Rc}; + use crate::{ math_utils::safe_div_usize, types::{ @@ -19,7 +21,6 @@ use crate::{ use felt::Felt; use num_integer::div_ceil; use starknet_crypto::{verify, FieldElement, Signature}; -use std::{cell::RefCell, collections::HashMap, rc::Rc}; use super::SIGNATURE_BUILTIN_NAME; @@ -270,7 +271,11 @@ mod tests { }, }; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_min_step_not_reached() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -285,6 +290,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_valid() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::new(10), true); let mut vm = vm!(); @@ -294,6 +300,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_for_ecdsa() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut segments = MemorySegmentManager::new(); @@ -302,6 +309,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_instances() { let builtin: BuiltinRunner = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true).into(); @@ -313,6 +321,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -336,6 +345,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_stop_pointer() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -363,6 +373,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_error_non_relocatable() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -386,6 +397,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_segment_addresses() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -393,6 +405,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_missing_segment_used_sizes() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -407,6 +420,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses_empty() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -419,6 +433,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_accesses() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -439,6 +454,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_missing_segment_used_sizes() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -453,6 +469,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_empty() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -465,6 +482,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells() { let builtin = BuiltinRunner::Signature(SignatureBuiltinRunner::new( &EcdsaInstanceDef::default(), @@ -477,6 +495,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_stack_for_range_check_with_base() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); builtin.base = 1; @@ -489,12 +508,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initial_stack_not_included_test() { let ecdsa_builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), false); assert_eq!(ecdsa_builtin.initial_stack(), Vec::new()) } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_test() { let memory = Memory::new(); let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -503,18 +524,21 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_ratio() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); assert_eq!(builtin.ratio(), 512); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_base() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); assert_eq!(builtin.base(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_memory_segment_addresses() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -522,6 +546,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell() { let memory = Memory::new(); let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -530,6 +555,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_allocated_memory_units_safe_div_fail() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -541,6 +567,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_safe_div_fail() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -559,6 +586,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_used_cells_and_allocated_size_insufficient_allocated() { let builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -573,6 +601,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_invalid_stop_pointer() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); @@ -588,6 +617,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn final_stack_no_used_instances() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut vm = vm!(); diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index fd5e6d67ef..86cf0eea7c 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -1,3 +1,10 @@ +use crate::stdlib::{ + any::Any, + collections::{HashMap, HashSet}, + ops::{Add, Sub}, + prelude::*, +}; + use crate::{ hint_processor::hint_processor_definition::{HintProcessor, HintReference}, math_utils::safe_div_usize, @@ -39,14 +46,8 @@ use crate::{ use felt::Felt; use num_integer::div_rem; use num_traits::Zero; -use std::{ - any::Any, - collections::{HashMap, HashSet}, - io, - ops::{Add, Sub}, -}; -use super::builtin_runner::{KeccakBuiltinRunner, OUTPUT_BUILTIN_NAME}; +use super::builtin_runner::KeccakBuiltinRunner; #[derive(Clone, Debug, Eq, PartialEq)] pub enum CairoArg { @@ -67,6 +68,7 @@ impl From> for CairoArg { } } +#[derive(Debug)] pub struct CairoRunner { pub(crate) program: Program, layout: CairoLayout, @@ -239,6 +241,7 @@ impl CairoRunner { self.layout._name.clone(), )); } + drop(inserted_builtins); vm.builtin_runners = builtin_runners; Ok(()) @@ -835,50 +838,6 @@ impl CairoRunner { }) } - pub fn get_output(&mut self, vm: &mut VirtualMachine) -> Result { - let mut output = Vec::::new(); - self.write_output(vm, &mut output)?; - let output = String::from_utf8(output).map_err(|_| RunnerError::FailedStringConversion)?; - Ok(output) - } - - /// Writes the values hosted in the output builtin's segment. - /// Does nothing if the output builtin is not present in the program. - pub fn write_output( - &mut self, - vm: &mut VirtualMachine, - stdout: &mut dyn io::Write, - ) -> Result<(), RunnerError> { - let (_, builtin) = match vm - .builtin_runners - .iter() - .find(|(k, _)| k == &OUTPUT_BUILTIN_NAME) - { - Some(x) => x, - _ => return Ok(()), - }; - - let segment_used_sizes = vm.segments.compute_effective_sizes(); - let segment_index = builtin.base(); - #[allow(deprecated)] - for i in 0..segment_used_sizes[segment_index] { - let formatted_value = match vm - .segments - .memory - .get(&Relocatable::from((segment_index as isize, i))) - { - Some(val) => match val.as_ref() { - MaybeRelocatable::Int(num) => format!("{}", num.to_bigint()), - MaybeRelocatable::RelocatableValue(rel) => format!("{}", rel), - }, - _ => "".to_string(), - }; - writeln!(stdout, "{formatted_value}").map_err(|_| RunnerError::WriteFail)?; - } - - Ok(()) - } - // Finalizes the segments. // Note: // 1. end_run() must precede a call to this method. @@ -1204,9 +1163,10 @@ impl Sub for ExecutionResources { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::collections::{HashMap, HashSet}; use crate::vm::runners::builtin_runner::{ BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, KECCAK_BUILTIN_NAME, - RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, + OUTPUT_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, }; use crate::vm::vm_memory::memory::MemoryCell; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; @@ -1221,12 +1181,12 @@ mod tests { use assert_matches::assert_matches; use felt::felt_str; use num_traits::One; - use std::{ - collections::{HashMap, HashSet}, - path::Path, - }; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_usage_ok_case() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::range_check, BuiltinName::output]; @@ -1238,6 +1198,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_memory_usage_err_case() { let program = program!(); @@ -1247,7 +1208,7 @@ mod tests { let mut builtin_runner: BuiltinRunner = OutputBuiltinRunner::new(true).into(); builtin_runner.initialize_segments(&mut vm.segments); - (OUTPUT_BUILTIN_NAME, builtin_runner) + (BuiltinName::output.name(), builtin_runner) }]; vm.segments.segment_used_sizes = Some(vec![4, 12]); vm.segments.memory = memory![((0, 0), 0), ((0, 1), 1), ((0, 2), 1)]; @@ -1261,6 +1222,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_builtins_with_disordered_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::range_check, BuiltinName::output]; @@ -1270,6 +1232,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn create_cairo_runner_with_ordered_but_missing_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output, BuiltinName::ecdsa]; @@ -1278,6 +1241,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_with_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output]; @@ -1311,6 +1275,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_no_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output]; @@ -1339,6 +1304,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_empty_data_and_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output]; @@ -1359,6 +1325,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_some_data_empty_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!( @@ -1381,6 +1348,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_empty_data_some_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output]; @@ -1397,6 +1365,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_no_program_base() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output]; @@ -1435,6 +1404,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_entrypoint_empty_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output]; @@ -1456,6 +1426,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_entrypoint_some_stack() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output]; @@ -1506,6 +1477,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(main = Some(1),); @@ -1518,12 +1490,16 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_state_program_segment_accessed_addrs() { // This test checks that all addresses from the program segment are marked as accessed at VM state initialization. // The fibonacci program has 24 instructions, so there should be 24 accessed addresses, // from (0, 0) to (0, 23). - let program = Program::from_file(Path::new("cairo_programs/fibonacci.json"), Some("main")) - .expect("Call to `Program::from_file()` failed."); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/fibonacci.json"), + Some("main"), + ) + .unwrap(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); @@ -1538,6 +1514,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_no_builtins() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(main = Some(1),); @@ -1554,6 +1531,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_with_range_check_valid() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(builtins = vec![BuiltinName::range_check], main = Some(1),); @@ -1582,6 +1560,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_vm_with_range_check_invalid() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program!(builtins = vec![BuiltinName::range_check], main = Some(1),); @@ -1605,6 +1584,7 @@ mod tests { //Integration tests for initialization phase #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: func myfunc(a: felt) -> (r: felt): let b = a * 2 @@ -1675,6 +1655,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -1752,6 +1733,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -1846,6 +1828,7 @@ mod tests { //Integration tests for initialization + execution phase #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: func myfunc(a: felt) -> (r: felt): let b = a * 2 @@ -1915,6 +1898,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -2015,6 +1999,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2127,6 +2112,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output range_check @@ -2286,6 +2272,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Memory from this test is taken from a cairo program execution Program used: func main(): @@ -2385,6 +2372,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output @@ -2540,6 +2528,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output @@ -2707,6 +2696,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_output_from_preset_memory() { let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); @@ -2718,12 +2708,14 @@ mod tests { vm.segments = segments![((2, 0), 1), ((2, 1), 2)]; vm.segments.segment_used_sizes = Some(vec![0, 0, 2]); - let mut stdout = Vec::::new(); - cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); - assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n2\n"))); + + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "1\n2\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2734,7 +2726,7 @@ mod tests { serialize_word(a) return() end */ - fn write_output_from_program() { + fn get_output_from_program() { //Initialization Phase let program = program!( builtins = vec![BuiltinName::output], @@ -2775,12 +2767,13 @@ mod tests { Ok(()) ); - let mut stdout = Vec::::new(); - cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); - assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n17\n"))); + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "1\n17\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins output @@ -2815,15 +2808,13 @@ mod tests { Ok(()) ); - let mut stdout = Vec::::new(); - cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); - assert_eq!( - String::from_utf8(stdout), - Ok(String::from("\n2:0\n")) - ); + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "\n2:0\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_output_from_preset_memory_neg_output() { let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); @@ -2840,14 +2831,16 @@ mod tests { ) )]; vm.segments.segment_used_sizes = Some(vec![0, 0, 1]); - let mut stdout = Vec::::new(); - cairo_runner.write_output(&mut vm, &mut stdout).unwrap(); - assert_eq!(String::from_utf8(stdout), Ok(String::from("-1\n"))); + + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "-1\n"); } - /// Test that `write_output()` works when the `output` builtin is not the first one. + /// Test that `get_output()` works when the `output` builtin is not the first one. #[test] - fn write_output_unordered_builtins() { + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] + fn get_output_unordered_builtins() { //Initialization Phase let program = program!( builtins = vec![BuiltinName::output, BuiltinName::bitwise], @@ -2901,14 +2894,13 @@ mod tests { Ok(()) ); - let mut stdout = Vec::::new(); - cairo_runner - .write_output(&mut vm, &mut stdout) - .expect("Call to `write_output()` failed."); - assert_eq!(String::from_utf8(stdout), Ok(String::from("1\n17\n"))); + let mut output_buffer = String::new(); + vm.write_output(&mut output_buffer).unwrap(); + assert_eq!(&output_buffer, "1\n17\n"); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_all_builtins_in_order() { let program = program![ BuiltinName::output, @@ -2928,6 +2920,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -2994,6 +2987,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -3064,6 +3058,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /*Program used: %builtins range_check @@ -3173,6 +3168,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_constants() { let program_constants = HashMap::from([ ("MAX".to_string(), Felt::new(300)), @@ -3184,6 +3180,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_missing_segment_used_sizes() { let program = program!(); @@ -3201,6 +3198,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty() { let program = program!(); @@ -3213,6 +3211,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty_builtins() { let program = program!(); @@ -3227,6 +3226,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty_accesses() { let program = program!(); @@ -3237,13 +3237,14 @@ mod tests { let mut builtin_runner: BuiltinRunner = OutputBuiltinRunner::new(true).into(); builtin_runner.initialize_segments(&mut vm.segments); - (OUTPUT_BUILTIN_NAME, builtin_runner) + (BuiltinName::output.name(), builtin_runner) }]; vm.segments.segment_used_sizes = Some(vec![4]); assert_eq!(cairo_runner.get_memory_holes(&vm), Ok(0)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes() { let program = program!(); @@ -3256,7 +3257,7 @@ mod tests { let mut builtin_runner: BuiltinRunner = OutputBuiltinRunner::new(true).into(); builtin_runner.initialize_segments(&mut vm.segments); - (OUTPUT_BUILTIN_NAME, builtin_runner) + (BuiltinName::output.name(), builtin_runner) }]; vm.segments.segment_used_sizes = Some(vec![4, 4]); assert_eq!(cairo_runner.get_memory_holes(&vm), Ok(2)); @@ -3265,6 +3266,7 @@ mod tests { /// Test that check_diluted_check_usage() works without a diluted pool /// instance. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_without_pool_instance() { let program = program!(); @@ -3277,6 +3279,7 @@ mod tests { /// Test that check_diluted_check_usage() works without builtin runners. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_without_builtin_runners() { let program = program!(); @@ -3291,6 +3294,7 @@ mod tests { /// Test that check_diluted_check_usage() fails when there aren't enough /// allocated units. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage_insufficient_allocated_cells() { let program = program!(); @@ -3310,6 +3314,7 @@ mod tests { /// Test that check_diluted_check_usage() succeeds when all the conditions /// are met. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_diluted_check_usage() { let program = program!(); @@ -3318,13 +3323,14 @@ mod tests { vm.current_step = 8192; vm.builtin_runners = vec![( - BITWISE_BUILTIN_NAME, + BuiltinName::bitwise.name(), BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true).into(), )]; assert_matches!(cairo_runner.check_diluted_check_usage(&vm), Ok(())); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_run_already_finished() { let program = program!(); @@ -3342,6 +3348,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run() { let program = program!(); @@ -3364,12 +3371,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_proof_mode_insufficient_allocated_cells() { - let program = Program::from_file( - Path::new("cairo_programs/proof_programs/fibonacci.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/proof_programs/fibonacci.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", true); @@ -3386,6 +3394,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtin_segments_info_empty() { let program = program!(); @@ -3396,6 +3405,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtin_segments_info_base_not_finished() { let program = program!(); @@ -3403,16 +3413,17 @@ mod tests { let mut vm = vm!(); vm.builtin_runners = vec![( - OUTPUT_BUILTIN_NAME, + BuiltinName::output.name(), BuiltinRunner::Output(OutputBuiltinRunner::new(true)), )]; assert_eq!( cairo_runner.get_builtin_segments_info(&vm), - Err(RunnerError::NoStopPointer(OUTPUT_BUILTIN_NAME)), + Err(RunnerError::NoStopPointer(BuiltinName::output.name())), ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources_trace_not_enabled() { let program = program!(); @@ -3431,6 +3442,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources_empty_builtins() { let program = program!(); @@ -3450,6 +3462,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_execution_resources() { let program = program!(); @@ -3462,19 +3475,23 @@ mod tests { let mut builtin = OutputBuiltinRunner::new(true); builtin.initialize_segments(&mut vm.segments); - (OUTPUT_BUILTIN_NAME, BuiltinRunner::Output(builtin)) + (BuiltinName::output.name(), BuiltinRunner::Output(builtin)) }]; assert_eq!( cairo_runner.get_execution_resources(&vm), Ok(ExecutionResources { n_steps: 10, n_memory_holes: 0, - builtin_instance_counter: HashMap::from([(OUTPUT_BUILTIN_NAME.to_string(), 4)]), + builtin_instance_counter: HashMap::from([( + BuiltinName::output.name().to_string(), + 4 + )]), }), ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_not_ended() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3486,6 +3503,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_no_prog_base() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3499,6 +3517,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_no_exec_base() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3513,6 +3532,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_empty_noproof_mode() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -3527,6 +3547,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_emptyproof_mode() { let program = program!(); let mut cairo_runner = cairo_runner!(program, "plain", true); @@ -3540,6 +3561,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_not_emptyproof_mode_empty_execution_public_memory() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -3572,6 +3594,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_segments_run_ended_not_emptyproof_mode_with_execution_public_memory() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4)]; @@ -3611,6 +3634,7 @@ mod tests { /// Test that ensures get_perm_range_check_limits() returns an error when /// trace is not enabled. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_trace_not_enabled() { let program = program!(); @@ -3628,6 +3652,7 @@ mod tests { /// Test that ensures get_perm_range_check_limits() returns None when the /// trace is empty (get_perm_range_check_limits returns None). #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_empty() { let program = program!(); @@ -3641,6 +3666,7 @@ mod tests { /// Test that get_perm_range_check_limits() works correctly when there are /// no builtins. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_no_builtins() { let program = program!(); @@ -3679,6 +3705,7 @@ mod tests { /// Test that get_perm_range_check_limits() works correctly when there are /// builtins. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits() { let program = program!(); @@ -3707,6 +3734,7 @@ mod tests { /// Test that check_range_check_usage() returns successfully when trace is /// not enabled. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_perm_range_limits_none() { let program = program!(); @@ -3720,6 +3748,7 @@ mod tests { /// Test that check_range_check_usage() returns successfully when all the /// conditions are met. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_without_builtins() { let program = program!(); @@ -3742,6 +3771,7 @@ mod tests { /// Test that check_range_check_usage() returns an error if there are /// insufficient allocated cells. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_range_check_usage_insufficient_allocated_cells() { let program = program!(); @@ -3769,6 +3799,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_fp_is_none_without_initialization() { let program = program!(); @@ -3778,6 +3809,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_initial_fp_can_be_obtained() { //This test works with basic Program definition, will later be updated to use Program::new() when fully defined let program = program![BuiltinName::output]; @@ -3796,6 +3828,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_valid_case() { let program = program![BuiltinName::range_check, BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); @@ -3808,6 +3841,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_get_used_cells_and_allocated_size_error() { let program = program!(); @@ -3835,6 +3869,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_check_memory_usage_error() { let program = program!(); @@ -3846,7 +3881,7 @@ mod tests { let mut builtin_runner: BuiltinRunner = OutputBuiltinRunner::new(true).into(); builtin_runner.initialize_segments(&mut vm.segments); - (OUTPUT_BUILTIN_NAME, builtin_runner) + (BuiltinName::output.name(), builtin_runner) }]; vm.segments.segment_used_sizes = Some(vec![4, 12]); vm.trace = Some(vec![]); @@ -3860,6 +3895,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn check_used_cells_check_diluted_check_usage_error() { let program = program![BuiltinName::range_check, BuiltinName::output]; let cairo_runner = cairo_runner!(program); @@ -3876,6 +3912,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_all_builtins() { let program = program!(); @@ -3898,6 +3935,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_all_builtins_maintain_program_order() { let program = program![ BuiltinName::pedersen, @@ -3924,6 +3962,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_function_runner() { let program = program!(); @@ -3962,6 +4001,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_plain_one_builtin() { let program = program![BuiltinName::output]; let mut vm = vm!(); @@ -3969,13 +4009,14 @@ mod tests { assert_eq!( cairo_runner.initialize_builtins(&mut vm), Err(RunnerError::NoBuiltinForInstance( - HashSet::from([OUTPUT_BUILTIN_NAME]), + HashSet::from([BuiltinName::output.name()]), String::from("plain") )) ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_plain_two_builtins() { let program = program![BuiltinName::output, BuiltinName::pedersen]; let mut vm = vm!(); @@ -3983,13 +4024,14 @@ mod tests { assert_eq!( cairo_runner.initialize_builtins(&mut vm), Err(RunnerError::NoBuiltinForInstance( - HashSet::from([OUTPUT_BUILTIN_NAME, HASH_BUILTIN_NAME]), + HashSet::from([BuiltinName::output.name(), HASH_BUILTIN_NAME]), String::from("plain") )) ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_segments_incorrect_layout_small_two_builtins() { let program = program![BuiltinName::output, BuiltinName::bitwise]; let mut vm = vm!(); @@ -3997,12 +4039,13 @@ mod tests { assert_eq!( cairo_runner.initialize_builtins(&mut vm), Err(RunnerError::NoBuiltinForInstance( - HashSet::from([BITWISE_BUILTIN_NAME]), + HashSet::from([BuiltinName::bitwise.name()]), String::from("small") )) ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint_proof_mode_empty_program() { let program = program!(start = Some(0), end = Some(0), main = Some(8),); let mut runner = cairo_runner!(program); @@ -4021,6 +4064,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn initialize_main_entrypoint_proof_mode_empty_program_two_builtins() { let program = program!( start = Some(0), @@ -4045,6 +4089,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn can_get_the_runner_program_builtins() { let program = program!( start = Some(0), @@ -4058,6 +4103,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main_default() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4084,6 +4130,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4124,6 +4171,7 @@ mod tests { /// Test that set_entrypoint() fails when the entrypoint doesn't exist. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn set_entrypoint_main_non_existent() { let program = program!(); let mut cairo_runner = cairo_runner!(program); @@ -4150,6 +4198,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4172,6 +4221,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test_with_run_not_ended() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4188,6 +4238,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_test_with_segments_finalized() { let mut program = program!(); program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4205,6 +4256,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_one_builtin_empty() { let mut program = program![BuiltinName::output]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4217,7 +4269,7 @@ mod tests { let mut vm = vm!(); let output_builtin = OutputBuiltinRunner::new(true); vm.builtin_runners - .push((OUTPUT_BUILTIN_NAME, output_builtin.into())); + .push((BuiltinName::output.name(), output_builtin.into())); vm.segments.memory.data = vec![ vec![], vec![Some(MemoryCell::new(MaybeRelocatable::from((0, 0))))], @@ -4235,6 +4287,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_one_builtin_one_element() { let mut program = program![BuiltinName::output]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4247,7 +4300,7 @@ mod tests { let mut vm = vm!(); let output_builtin = OutputBuiltinRunner::new(true); vm.builtin_runners - .push((OUTPUT_BUILTIN_NAME, output_builtin.into())); + .push((BuiltinName::output.name(), output_builtin.into())); vm.segments.memory.data = vec![ vec![Some(MemoryCell::new(MaybeRelocatable::from((0, 0))))], vec![Some(MemoryCell::new(MaybeRelocatable::from((0, 1))))], @@ -4265,6 +4318,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn read_return_values_updates_builtin_stop_ptr_two_builtins() { let mut program = program![BuiltinName::output, BuiltinName::bitwise]; program.data = vec_data![(1), (2), (3), (4), (5), (6), (7), (8)]; @@ -4278,9 +4332,9 @@ mod tests { let output_builtin = OutputBuiltinRunner::new(true); let bitwise_builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); vm.builtin_runners - .push((OUTPUT_BUILTIN_NAME, output_builtin.into())); + .push((BuiltinName::output.name(), output_builtin.into())); vm.builtin_runners - .push((BITWISE_BUILTIN_NAME, bitwise_builtin.into())); + .push((BuiltinName::bitwise.name(), bitwise_builtin.into())); cairo_runner.initialize_segments(&mut vm, None); vm.segments.memory.data = vec![ vec![Some(MemoryCell::new(MaybeRelocatable::from((0, 0))))], @@ -4310,6 +4364,7 @@ mod tests { /// Test that add_additional_hash_builtin() creates an additional builtin. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_additional_hash_builtin() { let program = program!(); let cairo_runner = cairo_runner!(program); @@ -4337,6 +4392,7 @@ mod tests { /// Test that add_additional_hash_builtin() replaces the created runner if called multiple /// times. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_additional_hash_builtin_replace() { let program = program!(); let cairo_runner = cairo_runner!(program); @@ -4363,9 +4419,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_from_entrypoint_custom_program_test() { - let program = - Program::from_file(Path::new("cairo_programs/example_program.json"), None).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/example_program.json"), + None, + ) + .unwrap(); let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(true); //this true expression dictates that the trace is enabled let mut hint_processor = BuiltinHintProcessor::new_empty(); @@ -4424,6 +4484,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_arg_from_single() { let expected = CairoArg::Single(MaybeRelocatable::from((0, 0))); let value = MaybeRelocatable::from((0, 0)); @@ -4431,6 +4492,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_arg_from_array() { let expected = CairoArg::Array(vec![MaybeRelocatable::from((0, 0))]); let value = vec![MaybeRelocatable::from((0, 0))]; @@ -4438,8 +4500,8 @@ mod tests { } fn setup_execution_resources() -> (ExecutionResources, ExecutionResources) { - let mut builtin_instance_counter: HashMap = HashMap::new(); - builtin_instance_counter.insert(OUTPUT_BUILTIN_NAME.to_string(), 8); + let mut builtin_instance_counter: HashMap = HashMap::new(); + builtin_instance_counter.insert(BuiltinName::output.name().to_string(), 8); let execution_resources_1 = ExecutionResources { n_steps: 100, @@ -4460,6 +4522,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn execution_resources_add() { let (execution_resources_1, execution_resources_2) = setup_execution_resources(); let combined_resources = execution_resources_1 + execution_resources_2; @@ -4469,7 +4532,7 @@ mod tests { assert_eq!( combined_resources .builtin_instance_counter - .get(OUTPUT_BUILTIN_NAME) + .get(BuiltinName::output.name()) .unwrap(), &16 ); @@ -4479,6 +4542,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn execution_resources_sub() { let (execution_resources_1, execution_resources_2) = setup_execution_resources(); @@ -4489,7 +4553,7 @@ mod tests { assert_eq!( combined_resources .builtin_instance_counter - .get(OUTPUT_BUILTIN_NAME) + .get(BuiltinName::output.name()) .unwrap(), &0 ); @@ -4499,9 +4563,10 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn run_from_entrypoint_substitute_error_message_test() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/error_msg_function.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/bad_programs/error_msg_function.json"), None, ) .unwrap(); @@ -4540,9 +4605,10 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_range_check_builtin() { - let program = Program::from_file( - Path::new("cairo_programs/assert_le_felt_hint.json"), + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/assert_le_felt_hint.json"), Some("main"), ) .unwrap(); @@ -4562,9 +4628,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_4_builtins() { - let program = - Program::from_file(Path::new("cairo_programs/integration.json"), Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/integration.json"), + Some("main"), + ) + .unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); @@ -4581,9 +4651,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_builtins_final_stack_no_builtins() { - let program = - Program::from_file(Path::new("cairo_programs/fibonacci.json"), Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/fibonacci.json"), + Some("main"), + ) + .unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); @@ -4600,10 +4674,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn filter_unused_builtins_test() { - let program = - Program::from_file(Path::new("cairo_programs/integration.json"), Some("main")).unwrap(); + let program = Program::from_bytes( + include_bytes!("../../../cairo_programs/integration.json"), + Some("main"), + ) + .unwrap(); let mut runner = cairo_runner!(program); let mut vm = vm!(); let end = runner.initialize(&mut vm).unwrap(); diff --git a/src/vm/security.rs b/src/vm/security.rs index 611d547f78..1e1b3cb9e7 100644 --- a/src/vm/security.rs +++ b/src/vm/security.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use num_traits::ToPrimitive; use super::{ @@ -82,6 +84,7 @@ mod test { use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::serde::deserialize_program::BuiltinName; + use crate::stdlib::collections::HashMap; use crate::types::relocatable::MaybeRelocatable; use crate::types::relocatable::Relocatable; use crate::vm::errors::memory_errors::MemoryError; @@ -91,9 +94,12 @@ mod test { use assert_matches::assert_matches; use felt::Felt; use num_traits::Zero; - use std::collections::HashMap; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_without_program_base() { let program = program!(); @@ -107,6 +113,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_empty_memory() { let program = program!(main = Some(0),); @@ -119,6 +126,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_program_access_out_of_bounds() { let program = program!(main = Some(0),); @@ -137,6 +145,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_builtin_access_out_of_bounds() { let program = program!(main = Some(0), builtins = vec![BuiltinName::range_check],); @@ -154,6 +163,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_builtin_access_correct() { let program = program!(main = Some(0), builtins = vec![BuiltinName::range_check],); @@ -173,6 +183,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_success() { let program = program!( data = vec![ @@ -200,6 +211,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_temporary_memory_properly_relocated() { let program = program!( data = vec![ @@ -227,6 +239,7 @@ mod test { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_secure_runner_temporary_memory_not_fully_relocated() { let program = program!( data = vec![ diff --git a/src/vm/trace/mod.rs b/src/vm/trace/mod.rs index 6f699c403a..a0e3794ffb 100644 --- a/src/vm/trace/mod.rs +++ b/src/vm/trace/mod.rs @@ -4,9 +4,9 @@ use super::{ errors::{memory_errors::MemoryError, vm_errors::VirtualMachineError}, vm_memory::memory::Memory, }; +use crate::stdlib::borrow::Cow; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; use num_traits::ToPrimitive; -use std::borrow::Cow; pub mod trace_entry; @@ -56,9 +56,13 @@ mod test { use crate::{utils::test_utils::*, vm::errors::memory_errors::MemoryError}; use assert_matches::assert_matches; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + /// Test that get_perm_range_check_limits() works as intended with an empty /// trace. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_empty_trace() { let trace = &[]; let memory = Memory::new(); @@ -69,6 +73,7 @@ mod test { /// Test that get_perm_range_check_limits() works as intended with a single /// trace element. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_single_element() { let trace = &[TraceEntry { pc: (0, 0).into(), @@ -86,6 +91,7 @@ mod test { /// Test that get_perm_range_check_limits() works as intended with multiple /// trace elements. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_perm_range_check_limits_multiple_elements() { let trace = &[ TraceEntry { diff --git a/src/vm/trace/trace_entry.rs b/src/vm/trace/trace_entry.rs index ce27abb48e..b9221a7d2d 100644 --- a/src/vm/trace/trace_entry.rs +++ b/src/vm/trace/trace_entry.rs @@ -1,3 +1,5 @@ +use crate::stdlib::prelude::*; + use crate::vm::errors::trace_errors::TraceError; use crate::{types::relocatable::Relocatable, vm::errors::memory_errors::MemoryError}; use serde::{Deserialize, Serialize}; @@ -37,6 +39,7 @@ mod tests { use super::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value() { let value = Relocatable { segment_index: 2, @@ -49,7 +52,11 @@ mod tests { ); } + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_relocatable_value_no_relocation() { let value = Relocatable { segment_index: 2, @@ -65,6 +72,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_temp_segment_address() { let value = Relocatable { segment_index: -2, diff --git a/src/vm/vm_core.rs b/src/vm/vm_core.rs index bd469ae037..72daf227bd 100644 --- a/src/vm/vm_core.rs +++ b/src/vm/vm_core.rs @@ -1,3 +1,5 @@ +use crate::stdlib::{any::Any, borrow::Cow, collections::HashMap, prelude::*}; + use crate::{ hint_processor::hint_processor_definition::HintProcessor, serde::deserialize_program::ApTracking, @@ -21,11 +23,13 @@ use crate::{ vm_memory::memory_segments::MemorySegmentManager, }, }; + use felt::Felt; use num_traits::{ToPrimitive, Zero}; -use std::{any::Any, borrow::Cow, collections::HashMap}; -use super::runners::builtin_runner::{RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME}; +use super::runners::builtin_runner::{ + OUTPUT_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, +}; const MAX_TRACEBACK_ENTRIES: u32 = 20; @@ -944,9 +948,41 @@ impl VirtualMachine { self.segments.gen_arg(arg) } - /// Calls MemorySegmentManager::compute_effective_sizes() - pub fn compute_effective_sizes(&mut self) -> &Vec { - self.segments.compute_effective_sizes() + /// Write the values hosted in the output builtin's segment. + /// Does nothing if the output builtin is not present in the program. + pub fn write_output( + &mut self, + writer: &mut impl core::fmt::Write, + ) -> Result<(), VirtualMachineError> { + let (_, builtin) = match self + .builtin_runners + .iter() + .find(|(k, _)| k == &OUTPUT_BUILTIN_NAME) + { + Some(x) => x, + _ => return Ok(()), + }; + + let segment_used_sizes = self.segments.compute_effective_sizes(); + let segment_index = builtin.base(); + #[allow(deprecated)] + for i in 0..segment_used_sizes[segment_index] { + let formatted_value = match self + .segments + .memory + .get(&Relocatable::from((segment_index as isize, i))) + { + Some(val) => match val.as_ref() { + MaybeRelocatable::Int(num) => format!("{}", num.to_bigint()), + MaybeRelocatable::RelocatableValue(rel) => format!("{}", rel), + }, + _ => "".to_string(), + }; + writeln!(writer, "{formatted_value}") + .map_err(|_| VirtualMachineError::FailedToWriteOutput)?; + } + + Ok(()) } } @@ -1050,6 +1086,8 @@ impl VirtualMachineBuilder { #[cfg(test)] mod tests { use super::*; + use crate::stdlib::collections::HashMap; + use crate::types::program::Program; use crate::vm::runners::builtin_runner::{ BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, }; @@ -1065,7 +1103,6 @@ mod tests { bitwise_instance_def::BitwiseInstanceDef, ec_op_instance_def::EcOpInstanceDef, }, instruction::{Op1Addr, Register}, - program::Program, relocatable::Relocatable, }, utils::test_utils::*, @@ -1078,12 +1115,14 @@ mod tests { }, }; use assert_matches::assert_matches; - use std::collections::HashMap; use felt::felt_str; - use std::path::Path; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_successful_without_imm() { let mut vm = vm!(); vm.segments = segments![((0, 0), 5)]; @@ -1094,6 +1133,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_successful_with_imm() { let mut vm = vm!(); @@ -1110,6 +1150,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_instruction_encoding_unsuccesful() { let vm = vm!(); assert_matches!( @@ -1119,6 +1160,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_ap_plus2() { let instruction = Instruction { off0: 1, @@ -1152,6 +1194,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_dst() { let instruction = Instruction { off0: 1, @@ -1185,6 +1228,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_regular() { let instruction = Instruction { off0: 1, @@ -1218,6 +1262,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_fp_dst_num() { let instruction = Instruction { off0: 1, @@ -1252,6 +1297,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add_with_res() { let instruction = Instruction { off0: 1, @@ -1288,6 +1334,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add_without_res() { let instruction = Instruction { off0: 1, @@ -1323,6 +1370,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add1() { let instruction = Instruction { off0: 1, @@ -1359,6 +1407,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_add2() { let instruction = Instruction { off0: 1, @@ -1395,6 +1444,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_ap_regular() { let instruction = Instruction { off0: 1, @@ -1431,6 +1481,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_regular_instruction_no_imm() { let instruction = Instruction { off0: 1, @@ -1464,6 +1515,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_regular_instruction_has_imm() { let instruction = Instruction { off0: 1, @@ -1497,6 +1549,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_with_res() { let instruction = Instruction { off0: 1, @@ -1530,6 +1583,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_without_res() { let instruction = Instruction { off0: 1, @@ -1565,6 +1619,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_with_int_res() { let instruction = Instruction { off0: 1, @@ -1599,6 +1654,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_without_res() { let instruction = Instruction { off0: 1, @@ -1631,6 +1687,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jump_rel_with_non_int_res() { let instruction = Instruction { off0: 1, @@ -1662,6 +1719,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jnz_dst_is_zero() { let instruction = Instruction { off0: 1, @@ -1695,6 +1753,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_pc_jnz_dst_is_not_zero() { let instruction = Instruction { off0: 1, @@ -1728,6 +1787,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_registers_all_regular() { let instruction = Instruction { off0: 1, @@ -1766,6 +1826,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn update_registers_mixed_types() { let instruction = Instruction { off0: 1, @@ -1802,18 +1863,21 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_int_value() { let value = MaybeRelocatable::Int(Felt::new(1)); assert!(!VirtualMachine::is_zero(&value)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_relocatable_value() { let value = MaybeRelocatable::from((1, 2)); assert!(!VirtualMachine::is_zero(&value)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_call() { let instruction = Instruction { off0: 1, @@ -1842,6 +1906,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_add_with_optionals() { let instruction = Instruction { off0: 1, @@ -1874,6 +1939,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_add_without_optionals() { let instruction = Instruction { off0: 1, @@ -1901,6 +1967,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_mul_non_zero_op1() { let instruction = Instruction { off0: 1, @@ -1933,6 +2000,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_mul_zero_op1() { let instruction = Instruction { off0: 1, @@ -1962,6 +2030,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_assert_eq_res_op1() { let instruction = Instruction { off0: 1, @@ -1991,6 +2060,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op0_opcode_ret() { let instruction = Instruction { off0: 1, @@ -2021,6 +2091,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_call() { let instruction = Instruction { off0: 1, @@ -2048,6 +2119,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_add_with_optionals() { let instruction = Instruction { off0: 1, @@ -2079,6 +2151,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_add_without_optionals() { let instruction = Instruction { off0: 1, @@ -2105,6 +2178,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_mul_non_zero_op0() { let instruction = Instruction { off0: 1, @@ -2136,6 +2210,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_mul_zero_op0() { let instruction = Instruction { off0: 1, @@ -2165,6 +2240,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_op1_without_dst() { let instruction = Instruction { off0: 1, @@ -2193,6 +2269,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_op1_opcode_assert_eq_res_op1_with_dst() { let instruction = Instruction { off0: 1, @@ -2223,6 +2300,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_op1() { let instruction = Instruction { off0: 1, @@ -2252,6 +2330,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_add() { let instruction = Instruction { off0: 1, @@ -2281,6 +2360,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_mul_int_operands() { let instruction = Instruction { off0: 1, @@ -2310,6 +2390,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_mul_relocatable_values() { let instruction = Instruction { off0: 1, @@ -2337,6 +2418,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_res_unconstrained() { let instruction = Instruction { off0: 1, @@ -2364,6 +2446,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_assert_eq_with_res() { let instruction = Instruction { off0: 1, @@ -2390,6 +2473,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_assert_eq_without_res() { let instruction = Instruction { off0: 1, @@ -2412,6 +2496,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_call() { let instruction = Instruction { off0: 1, @@ -2437,6 +2522,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_dst_opcode_ret() { let instruction = Instruction { off0: 1, @@ -2459,6 +2545,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_add_ap() { let inst = Instruction { off0: 0, @@ -2519,6 +2606,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_mul_fp() { let inst = Instruction { off0: 0, @@ -2578,6 +2666,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_jnz() { let instruction = Instruction { off0: 1, @@ -2631,6 +2720,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_operands_deduce_dst_none() { let instruction = Instruction { off0: 2, @@ -2656,6 +2746,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_res_unconstrained() { let instruction = Instruction { off0: 1, @@ -2686,6 +2777,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_instruction_failed() { let instruction = Instruction { off0: 1, @@ -2722,6 +2814,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_instruction_failed_relocatables() { let instruction = Instruction { off0: 1, @@ -2757,6 +2850,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_inconsistent_op0() { let instruction = Instruction { off0: 1, @@ -2793,6 +2887,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn opcode_assertions_inconsistent_dst() { let instruction = Instruction { off0: 1, @@ -2828,6 +2923,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /// Test for a simple program execution /// Used program code: /// func main(): @@ -2881,6 +2977,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Test for a simple program execution Used program code: @@ -2995,6 +3092,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /// Test the following program: /// ... /// [ap] = 4 @@ -3105,12 +3203,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_no_pedersen_builtin() { let vm = vm!(); assert_matches!(vm.deduce_memory_cell(Relocatable::from((0, 0))), Ok(None)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_pedersen_builtin_valid() { let mut vm = vm!(); let builtin = HashBuiltinRunner::new(8, true); @@ -3125,6 +3225,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output pedersen from starkware.cairo.common.cairo_builtins import HashBuiltin @@ -3211,6 +3312,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_bitwise_builtin_valid_and() { let mut vm = vm!(); let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); @@ -3224,6 +3326,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3291,6 +3394,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn deduce_memory_cell_ec_op_builtin_valid() { let mut vm = vm!(); let builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); @@ -3345,6 +3449,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Data taken from this program execution: %builtins output ec_op from starkware.cairo.common.cairo_builtins import EcOpBuiltin @@ -3409,6 +3514,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn verify_auto_deductions_for_ec_op_builtin_valid_points_invalid_result() { let mut builtin = EcOpBuiltinRunner::new(&EcOpInstanceDef::default(), true); builtin.base = 3; @@ -3472,6 +3578,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3495,6 +3602,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins bitwise from starkware.cairo.common.bitwise import bitwise_and @@ -3524,6 +3632,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] /* Program used: %builtins output pedersen from starkware.cairo.common.cairo_builtins import HashBuiltin @@ -3557,6 +3666,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn can_get_return_values() { let mut vm = vm!(); vm.set_ap(4); @@ -3571,6 +3681,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_return_values_fails_when_ap_is_0() { let mut vm = vm!(); vm.segments = segments![((1, 0), 1), ((1, 1), 2), ((1, 2), 3), ((1, 3), 4)]; @@ -3599,6 +3710,7 @@ mod tests { */ #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_step_for_preset_memory_with_alloc_hint() { let mut vm = vm!(true); let hint_data_dictionary = HashMap::from([( @@ -3677,6 +3789,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_get_builtin_runners() { let mut vm = vm!(); let hash_builtin = HashBuiltinRunner::new(8, true); @@ -3693,6 +3806,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn disable_trace() { let mut vm = VirtualMachine::new(true); assert!(vm.trace.is_some()); @@ -3701,6 +3815,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -3718,6 +3833,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_non_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -3736,6 +3852,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -3752,6 +3869,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_non_continuous_memory() { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -3763,6 +3881,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_after_computing_used() { let mut vm = vm!(); vm.segments = segments![ @@ -3779,12 +3898,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_before_computing_used() { let vm = vm!(); assert_eq!(None, vm.get_segment_used_size(2)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_and_set_pc() { let mut vm = vm!(); vm.set_pc(Relocatable { @@ -3801,6 +3922,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_and_set_fp() { let mut vm = vm!(); vm.set_fp(3); @@ -3814,6 +3936,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_key_not_in_memory() { let vm = vm!(); assert_eq!( @@ -3826,12 +3949,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_error() { let vm = vm!(); assert_eq!(vm.get_maybe(&MaybeRelocatable::Int(Felt::new(0_i32))), None,); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn end_run_error() { let mut vm = vm!(); let scopes = exec_scopes_ref!(); @@ -3846,6 +3971,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_temporary_segments() { let mut vm = vm!(); let mut _base = vm.add_temporary_segment(); @@ -3867,6 +3993,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn decode_current_instruction_invalid_encoding() { let mut vm = vm!(); vm.segments = segments![((0, 0), ("112233445566778899", 16))]; @@ -3877,6 +4004,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocation_rule_test() { let mut vm = vm!(); @@ -3903,6 +4031,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_relocatable() { let mut vm = vm!(); @@ -3915,6 +4044,7 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and no prime number just /// passes the value through. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint() { let mut vm = vm!(); @@ -3927,6 +4057,7 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and a prime number passes /// the value through after applying the modulo. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint_prime() { let mut vm = vm!(); let prime = felt_str!(felt::PRIME_STR[2..], 16); @@ -3938,6 +4069,7 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec() { let mut vm = vm!(); @@ -3958,6 +4090,7 @@ mod tests { /// Test that compute_effective_sizes() works as intended. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes() { let mut vm = vm!(); @@ -3973,7 +4106,7 @@ mod tests { ) .expect("Could not load data into memory."); - assert_eq!(vm.compute_effective_sizes(), &vec![4]); + assert_eq!(vm.segments.compute_effective_sizes(), &vec![4]); } /// Test that compute_segment_effective_sizes() works as intended. @@ -3998,6 +4131,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed() { let mut vm = vm!(); vm.run_finished = true; @@ -4035,6 +4169,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed_run_not_finished() { let mut vm = vm!(); assert_matches!( @@ -4044,6 +4179,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn mark_as_accessed_missing_accessed_addresses() { let mut vm = vm!(); assert_matches!( @@ -4053,12 +4189,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_entries_bad_usort() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_usort.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/bad_programs/bad_usort.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -4077,12 +4214,13 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_traceback_entries_bad_dict_update() { - let program = Program::from_file( - Path::new("cairo_programs/bad_programs/bad_dict_update.json"), + let program = Program::from_bytes( + include_bytes!("../../cairo_programs/bad_programs/bad_dict_update.json"), Some("main"), ) - .expect("Call to `Program::from_file()` failed."); + .unwrap(); let mut hint_processor = BuiltinHintProcessor::new_empty(); let mut cairo_runner = cairo_runner!(program, "all", false); @@ -4167,8 +4305,8 @@ mod tests { ); #[cfg(feature = "hooks")] { - let program = crate::types::program::Program::from_file( - Path::new("cairo_programs/sqrt.json"), + let program = crate::types::program::Program::from_bytes( + include_bytes!("../../cairo_programs/sqrt.json"), Some("main"), ) .expect("Call to `Program::from_file()` failed."); diff --git a/src/vm/vm_memory/memory.rs b/src/vm/vm_memory/memory.rs index 6f6afe4892..da80a04cc2 100644 --- a/src/vm/vm_memory/memory.rs +++ b/src/vm/vm_memory/memory.rs @@ -1,3 +1,10 @@ +use crate::stdlib::{ + borrow::Cow, + collections::{HashMap, HashSet}, + fmt, + prelude::*, +}; + use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, utils::from_relocatable_to_indexes, @@ -5,11 +12,7 @@ use crate::{ }; use felt::Felt; use num_traits::ToPrimitive; -use std::{ - borrow::Cow, - collections::{HashMap, HashSet}, - fmt::{Display, Formatter}, -}; + pub struct ValidationRule( #[allow(clippy::type_complexity)] pub Box Result, MemoryError>>, @@ -355,8 +358,8 @@ impl Memory { } } -impl Display for Memory { - fn fmt(&self, f: &mut Formatter) -> std::fmt::Result { +impl fmt::Display for Memory { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for (i, segment) in self.temp_data.iter().enumerate() { for (j, cell) in segment.iter().enumerate() { if let Some(cell) = cell { @@ -424,7 +427,7 @@ impl Default for Memory { #[cfg(test)] mod memory_tests { - use std::ops::Shl; + use core::ops::Shl; use super::*; use crate::{ @@ -445,6 +448,9 @@ mod memory_tests { use crate::utils::test_utils::memory_from_memory; use crate::utils::test_utils::memory_inner; + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; + pub fn memory_from( key_val_list: Vec<(MaybeRelocatable, MaybeRelocatable)>, num_segements: usize, @@ -460,6 +466,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_succesful() { let key = MaybeRelocatable::from((0, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -473,6 +480,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_valuef_from_temp_segment() { let mut memory = Memory::new(); memory.temp_data = vec![vec![ @@ -487,6 +495,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_value_in_temp_segment() { let key = MaybeRelocatable::from((-1, 3)); let val = MaybeRelocatable::from(Felt::new(8)); @@ -500,6 +509,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_succesful() { let key = MaybeRelocatable::from((-1, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -513,6 +523,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_failed() { let key = mayberelocatable!(-1, 1); let mut memory = Memory::new(); @@ -528,6 +539,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_allocated_memory() { let key = MaybeRelocatable::from((0, 0)); let memory = Memory::new(); @@ -535,6 +547,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_existant_element() { let key = MaybeRelocatable::from((0, 0)); let memory = Memory::new(); @@ -542,6 +555,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_relocatable_key() { let key = MaybeRelocatable::from(Felt::new(0)); let memory = Memory::new(); @@ -549,6 +563,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_allocated_memory() { let key = MaybeRelocatable::from((0, 0)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -558,6 +573,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_inconsistent_memory() { let key = MaybeRelocatable::from((0, 0)); let val_a = MaybeRelocatable::from(Felt::new(5)); @@ -575,6 +591,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_address_not_relocatable() { let key = MaybeRelocatable::from(Felt::new(5)); let val = MaybeRelocatable::from(Felt::new(5)); @@ -588,6 +605,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_contiguous_element() { let key_a = MaybeRelocatable::from((0, 0)); let key_b = MaybeRelocatable::from((0, 2)); @@ -600,6 +618,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_contiguous_element_memory_gaps_none() { let key_a = MaybeRelocatable::from((0, 0)); let key_b = MaybeRelocatable::from((0, 5)); @@ -616,6 +635,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_array_test() { let mem = memory_from( vec![( @@ -629,6 +649,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_within_bounds() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -653,6 +674,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_outside_bounds() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -677,6 +699,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_invalid_signature() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); let mut segments = MemorySegmentManager::new(); @@ -703,6 +726,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_valid_signature() { let mut builtin = SignatureBuiltinRunner::new(&EcdsaInstanceDef::default(), true); @@ -740,6 +764,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_relocatable_value() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -754,6 +779,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_out_of_bounds_diff_segment() { let mut builtin = RangeCheckBuiltinRunner::new(8, 8, true); let mut segments = MemorySegmentManager::new(); @@ -772,6 +798,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_valid() { let memory = memory![((0, 0), 10)]; assert_eq!( @@ -784,6 +811,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_integer_invalid_expected_integer() { let mut segments = MemorySegmentManager::new(); segments.add(); @@ -803,12 +831,14 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn default_memory() { let mem: Memory = Default::default(); assert_eq!(mem.data.len(), 0); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_temporary_succesful() { let mut memory = Memory::new(); memory.temp_data.push(Vec::new()); @@ -821,6 +851,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocation_rule() { let mut memory = Memory::new(); @@ -847,6 +878,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_bigint() { let mut memory = Memory::new(); memory @@ -864,6 +896,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable() { let mut memory = Memory::new(); memory @@ -885,6 +918,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable_temporary_segment_no_rules() { let mut memory = Memory::new(); memory @@ -903,6 +937,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_value_mayberelocatable_temporary_segment_rules() { let mut memory = Memory::new(); memory @@ -931,7 +966,9 @@ mod memory_tests { Cow::Owned(MaybeRelocatable::RelocatableValue((2, 7).into())), ); } + #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -948,6 +985,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_range_for_non_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -965,6 +1003,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; @@ -980,6 +1019,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_continuous_range_for_non_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; @@ -991,6 +1031,7 @@ mod memory_tests { /// Test that relocate_memory() works when there are no relocation rules. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_empty_relocation_rules() { let mut memory = memory![((0, 0), 1), ((0, 1), 2), ((0, 2), 3)]; @@ -999,6 +1040,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_with_gap() { let mut memory = memory![ ((0, 0), 1), @@ -1033,6 +1075,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment() { let mut memory = memory![ ((0, 0), 1), @@ -1068,6 +1111,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_unallocated() { let mut memory = memory![ ((0, 0), 1), @@ -1091,6 +1135,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment() { let mut memory = memory![ ((0, 0), 1), @@ -1125,6 +1170,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment_inconsistent_memory() { let mut memory = memory![ ((0, 0), 1), @@ -1152,6 +1198,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_2_temporary_segments_one_relocated() { let mut memory = memory![ ((0, 0), 1), @@ -1189,6 +1236,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_new_segment_2_temporary_segments_relocated() { let mut memory = memory![ ((0, 0), 1), @@ -1232,6 +1280,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn test_memory_display() { let memory = memory![ ((0, 0), 1), @@ -1251,6 +1300,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_memory_into_existing_segment_temporary_values_in_temporary_memory() { let mut memory = memory![ ((0, 0), 1), @@ -1284,6 +1334,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_with_rules() { let mut memory = Memory::new(); memory @@ -1304,6 +1355,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_no_rules() { let memory = Memory::new(); assert_eq!( @@ -1317,6 +1369,7 @@ mod memory_tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_address_real_addr() { let memory = Memory::new(); assert_eq!( diff --git a/src/vm/vm_memory/memory_segments.rs b/src/vm/vm_memory/memory_segments.rs index 1e59bbfcd6..6bef9c4673 100644 --- a/src/vm/vm_memory/memory_segments.rs +++ b/src/vm/vm_memory/memory_segments.rs @@ -1,4 +1,7 @@ +use crate::stdlib::prelude::*; +use crate::stdlib::{any::Any, collections::HashMap}; use crate::vm::runners::cairo_runner::CairoArg; + use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, vm::{ @@ -6,7 +9,6 @@ use crate::{ vm_memory::memory::Memory, }, }; -use std::{any::Any, collections::HashMap}; pub struct MemorySegmentManager { pub segment_sizes: HashMap, @@ -238,9 +240,12 @@ mod tests { use assert_matches::assert_matches; use felt::Felt; use num_traits::Num; - use std::vec; + + #[cfg(target_arch = "wasm32")] + use wasm_bindgen_test::*; #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_segment_no_size() { let mut segments = MemorySegmentManager::new(); let base = segments.add(); @@ -249,6 +254,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_segment_no_size_test_two_segments() { let mut segments = MemorySegmentManager::new(); let mut _base = segments.add(); @@ -264,6 +270,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_one_temporary_segment() { let mut segments = MemorySegmentManager::new(); let base = segments.add_temporary_segment(); @@ -272,6 +279,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_two_temporary_segments() { let mut segments = MemorySegmentManager::new(); segments.add_temporary_segment(); @@ -287,6 +295,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_empty() { let data = Vec::new(); let ptr = Relocatable::from((0, 3)); @@ -296,6 +305,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_one_element() { let data = vec![MaybeRelocatable::from(Felt::new(4))]; let ptr = Relocatable::from((0, 0)); @@ -310,6 +320,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_three_elements() { let data = vec![ MaybeRelocatable::from(Felt::new(4)), @@ -344,6 +355,7 @@ mod tests { ); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory() { let mut segments = segments![((0, 0), 1), ((0, 1), 1), ((0, 2), 1)]; segments.compute_effective_sizes(); @@ -351,6 +363,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory_with_gap() { let mut segments = MemorySegmentManager::new(); segments.add(); @@ -366,6 +379,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_one_segment_memory_with_gaps() { let mut segments = segments![((0, 3), 1), ((0, 4), 1), ((0, 7), 1), ((0, 9), 1)]; segments.compute_effective_sizes(); @@ -373,6 +387,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_three_segment_memory() { let mut segments = segments![ ((0, 0), 1), @@ -390,6 +405,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_effective_sizes_for_three_segment_memory_with_gaps() { let mut segments = segments![ ((0, 2), 1), @@ -405,6 +421,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_after_computing_used() { let mut segments = segments![ ((0, 2), 1), @@ -420,12 +437,14 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_segment_used_size_before_computing_used() { let segments = MemorySegmentManager::new(); assert_eq!(None, segments.get_segment_used_size(2)); } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_segments_one_segment() { let mut segments = MemorySegmentManager::new(); segments.segment_used_sizes = Some(vec![3]); @@ -438,6 +457,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_segments_five_segment() { let mut segments = MemorySegmentManager::new(); segments.segment_used_sizes = Some(vec![3, 3, 56, 78, 8]); @@ -450,6 +470,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_arg_with_apply_modulo() { let mut big_num = num_bigint::BigInt::from_str_radix(&felt::PRIME_STR[2..], 16) .expect("Couldn't parse prime"); @@ -476,6 +497,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn write_arg_relocatable() { let data = vec![ Relocatable::from((0, 1)), @@ -502,6 +524,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn segment_default() { let segment_mng_new = MemorySegmentManager::new(); let segment_mng_def: MemorySegmentManager = Default::default(); @@ -516,6 +539,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_missing_effective_sizes() { let segment_manager = MemorySegmentManager::new(); @@ -526,6 +550,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_temporary_segment() { let mut segment_manager = MemorySegmentManager::new(); @@ -537,6 +562,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value_invalid_segment() { let mut segment_manager = MemorySegmentManager::new(); @@ -548,6 +574,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_valid_memory_value() { let mut segment_manager = MemorySegmentManager::new(); @@ -559,6 +586,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_missing_segment_used_sizes() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.memory = memory![((0, 0), 0)]; @@ -572,6 +600,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_out_of_address_offset_bigger_than_size() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![2]); @@ -590,6 +619,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(Vec::new()); @@ -597,6 +627,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes_empty2() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![4]); @@ -604,6 +635,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![10]); @@ -626,6 +658,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_holes2() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -650,6 +683,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size_missing_segment() { let memory_segment_manager = MemorySegmentManager::new(); @@ -657,6 +691,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size_used() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_used_sizes = Some(vec![5]); @@ -665,6 +700,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_sizes = HashMap::from([(0, 5)]); @@ -673,6 +709,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_memory_size2() { let mut memory_segment_manager = MemorySegmentManager::new(); memory_segment_manager.segment_sizes = HashMap::from([(0, 5)]); @@ -684,6 +721,7 @@ mod tests { /// Test that the call to .gen_arg() with a relocatable just passes the /// value through. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_relocatable() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -696,6 +734,7 @@ mod tests { /// Test that the call to .gen_arg() with a bigint and no prime number just /// passes the value through. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_bigint() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -708,6 +747,7 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -731,6 +771,7 @@ mod tests { /// Test that the call to .gen_arg() with a Vec writes its /// contents into a new segment and returns a pointer to it. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_vec_relocatable() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -750,6 +791,7 @@ mod tests { /// Test that the call to .gen_arg() with any other argument returns a not /// implemented error. #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_arg_invalid_type() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -760,6 +802,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_size_nor_memory_no_change() { let mut segments = MemorySegmentManager::new(); segments.finalize(None, 0, None); @@ -771,6 +814,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_memory() { let mut segments = MemorySegmentManager::new(); segments.finalize(Some(42), 0, None); @@ -779,6 +823,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_no_size() { let mut segments = MemorySegmentManager::new(); segments.finalize(None, 0, Some(&vec![(1_usize, 2_usize)])); @@ -790,6 +835,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn finalize_all_args() { let mut segments = MemorySegmentManager::new(); segments.finalize(Some(42), 0, Some(&vec![(1_usize, 2_usize)])); @@ -801,6 +847,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_single() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -811,6 +858,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_array() { let mut memory_segment_manager = MemorySegmentManager::new(); @@ -833,6 +881,7 @@ mod tests { } #[test] + #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn gen_cairo_arg_composed() { let mut memory_segment_manager = MemorySegmentManager::new(); let cairo_args = CairoArg::Composed(vec![ diff --git a/src/with_alloc.rs b/src/with_alloc.rs new file mode 100644 index 0000000000..450af26178 --- /dev/null +++ b/src/with_alloc.rs @@ -0,0 +1,15 @@ +#[macro_use] +pub extern crate alloc; + +pub mod with_alloc { + pub use alloc::borrow; + pub use alloc::boxed; + pub use alloc::rc; + pub use alloc::string; + pub use alloc::sync; + pub use alloc::vec; + + pub mod collections { + pub use hashbrown::{HashMap, HashSet}; + } +} diff --git a/src/with_std.rs b/src/with_std.rs new file mode 100644 index 0000000000..2b30649c4e --- /dev/null +++ b/src/with_std.rs @@ -0,0 +1,34 @@ +// Inspired by Substrate sp-std crate +// see https://github.com/paritytech/substrate/blob/master/primitives/std/with_std.rs + +pub mod with_std { + pub use core::time; + pub use std::alloc; + pub use std::any; + pub use std::borrow; + pub use std::boxed; + pub use std::cell; + pub use std::clone; + pub use std::cmp; + pub use std::convert; + pub use std::default; + pub use std::fmt; + pub use std::hash; + pub use std::iter; + pub use std::marker; + pub use std::mem; + pub use std::num; + pub use std::ops; + pub use std::ptr; + pub use std::rc; + pub use std::result; + pub use std::slice; + pub use std::str; + pub use std::string; + pub use std::sync; + pub use std::vec; + + pub mod collections { + pub use std::collections::{HashMap, HashSet}; + } +} diff --git a/src/without_std.rs b/src/without_std.rs new file mode 100644 index 0000000000..1fb0b9746c --- /dev/null +++ b/src/without_std.rs @@ -0,0 +1,24 @@ +// Inspired by Substrate sp-std crate +// see https://github.com/paritytech/substrate/blob/master/primitives/std/without_std.rs + +pub mod without_std { + pub use core::any; + pub use core::borrow; + pub use core::cell; + pub use core::clone; + pub use core::cmp; + pub use core::convert; + pub use core::default; + pub use core::fmt; + pub use core::hash; + pub use core::iter; + pub use core::marker; + pub use core::mem; + pub use core::num; + pub use core::ops; + pub use core::ptr; + pub use core::result; + pub use core::slice; + pub use core::str; + pub use core::time; +} diff --git a/tests/cairo_run_test.rs b/tests/cairo_run_test.rs index d4b7bd88aa..c1bbb9f0a7 100644 --- a/tests/cairo_run_test.rs +++ b/tests/cairo_run_test.rs @@ -1,8 +1,11 @@ use cairo_vm::cairo_run; use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; -use std::path::Path; + +#[cfg(target_arch = "wasm32")] +use wasm_bindgen_test::*; #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -10,7 +13,7 @@ fn cairo_run_test() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/fibonacci.json"), + include_bytes!("../cairo_programs/fibonacci.json"), &cairo_run_config, &mut hint_executor, ) @@ -18,6 +21,7 @@ fn cairo_run_test() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_array_sum() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -25,7 +29,7 @@ fn cairo_run_array_sum() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/array_sum.json"), + include_bytes!("../cairo_programs/array_sum.json"), &cairo_run_config, &mut hint_executor, ) @@ -33,6 +37,7 @@ fn cairo_run_array_sum() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_big_struct() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -40,7 +45,7 @@ fn cairo_run_big_struct() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/big_struct.json"), + include_bytes!("../cairo_programs/big_struct.json"), &cairo_run_config, &mut hint_executor, ) @@ -48,6 +53,7 @@ fn cairo_run_big_struct() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_call_function_assign_param_by_name() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -55,7 +61,7 @@ fn cairo_run_call_function_assign_param_by_name() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/call_function_assign_param_by_name.json"), + include_bytes!("../cairo_programs/call_function_assign_param_by_name.json"), &cairo_run_config, &mut hint_executor, ) @@ -63,6 +69,7 @@ fn cairo_run_call_function_assign_param_by_name() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -70,7 +77,7 @@ fn cairo_run_function_return() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/function_return.json"), + include_bytes!("../cairo_programs/function_return.json"), &cairo_run_config, &mut hint_executor, ) @@ -78,6 +85,7 @@ fn cairo_run_function_return() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return_if_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -85,7 +93,7 @@ fn cairo_run_function_return_if_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/function_return_if_print.json"), + include_bytes!("../cairo_programs/function_return_if_print.json"), &cairo_run_config, &mut hint_executor, ) @@ -93,6 +101,7 @@ fn cairo_run_function_return_if_print() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_function_return_to_variable() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -100,7 +109,7 @@ fn cairo_run_function_return_to_variable() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/function_return_to_variable.json"), + include_bytes!("../cairo_programs/function_return_to_variable.json"), &cairo_run_config, &mut hint_executor, ) @@ -108,6 +117,7 @@ fn cairo_run_function_return_to_variable() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_and_prime() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -115,7 +125,7 @@ fn cairo_run_if_and_prime() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/if_and_prime.json"), + include_bytes!("../cairo_programs/if_and_prime.json"), &cairo_run_config, &mut hint_executor, ) @@ -123,6 +133,7 @@ fn cairo_run_if_and_prime() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_in_function() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -130,7 +141,7 @@ fn cairo_run_if_in_function() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/if_in_function.json"), + include_bytes!("../cairo_programs/if_in_function.json"), &cairo_run_config, &mut hint_executor, ) @@ -138,6 +149,7 @@ fn cairo_run_if_in_function() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_if_list() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -145,7 +157,7 @@ fn cairo_run_if_list() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/if_list.json"), + include_bytes!("../cairo_programs/if_list.json"), &cairo_run_config, &mut hint_executor, ) @@ -153,6 +165,7 @@ fn cairo_run_if_list() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_jmp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -160,7 +173,7 @@ fn cairo_run_jmp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/jmp.json"), + include_bytes!("../cairo_programs/jmp.json"), &cairo_run_config, &mut hint_executor, ) @@ -168,6 +181,7 @@ fn cairo_run_jmp() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_jmp_if_condition() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -175,7 +189,7 @@ fn cairo_run_jmp_if_condition() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/jmp_if_condition.json"), + include_bytes!("../cairo_programs/jmp_if_condition.json"), &cairo_run_config, &mut hint_executor, ) @@ -183,6 +197,7 @@ fn cairo_run_jmp_if_condition() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_pointers() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -190,7 +205,7 @@ fn cairo_run_pointers() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/pointers.json"), + include_bytes!("../cairo_programs/pointers.json"), &cairo_run_config, &mut hint_executor, ) @@ -198,6 +213,7 @@ fn cairo_run_pointers() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -205,7 +221,7 @@ fn cairo_run_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/print.json"), + include_bytes!("../cairo_programs/print.json"), &cairo_run_config, &mut hint_executor, ) @@ -213,6 +229,7 @@ fn cairo_run_print() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_return() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -220,7 +237,7 @@ fn cairo_run_return() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/return.json"), + include_bytes!("../cairo_programs/return.json"), &cairo_run_config, &mut hint_executor, ) @@ -228,6 +245,7 @@ fn cairo_run_return() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_reversed_register_instructions() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -235,7 +253,7 @@ fn cairo_run_reversed_register_instructions() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/reversed_register_instructions.json"), + include_bytes!("../cairo_programs/reversed_register_instructions.json"), &cairo_run_config, &mut hint_executor, ) @@ -243,6 +261,7 @@ fn cairo_run_reversed_register_instructions() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_simple_print() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -250,7 +269,7 @@ fn cairo_run_simple_print() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/simple_print.json"), + include_bytes!("../cairo_programs/simple_print.json"), &cairo_run_config, &mut hint_executor, ) @@ -258,6 +277,7 @@ fn cairo_run_simple_print() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_addition_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -265,7 +285,7 @@ fn cairo_run_test_addition_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/test_addition_if.json"), + include_bytes!("../cairo_programs/test_addition_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -273,6 +293,7 @@ fn cairo_run_test_addition_if() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_reverse_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -280,7 +301,7 @@ fn cairo_run_test_reverse_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/test_reverse_if.json"), + include_bytes!("../cairo_programs/test_reverse_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -288,6 +309,7 @@ fn cairo_run_test_reverse_if() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_test_subtraction_if() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -295,7 +317,7 @@ fn cairo_run_test_subtraction_if() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/test_subtraction_if.json"), + include_bytes!("../cairo_programs/test_subtraction_if.json"), &cairo_run_config, &mut hint_executor, ) @@ -303,6 +325,7 @@ fn cairo_run_test_subtraction_if() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_use_imported_module() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -310,7 +333,7 @@ fn cairo_run_use_imported_module() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/use_imported_module.json"), + include_bytes!("../cairo_programs/use_imported_module.json"), &cairo_run_config, &mut hint_executor, ) @@ -318,6 +341,7 @@ fn cairo_run_use_imported_module() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_bitwise_output() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -325,7 +349,7 @@ fn cairo_run_bitwise_output() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/bitwise_output.json"), + include_bytes!("../cairo_programs/bitwise_output.json"), &cairo_run_config, &mut hint_executor, ) @@ -333,6 +357,7 @@ fn cairo_run_bitwise_output() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_bitwise_recursion() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -340,7 +365,7 @@ fn cairo_run_bitwise_recursion() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/bitwise_recursion.json"), + include_bytes!("../cairo_programs/bitwise_recursion.json"), &cairo_run_config, &mut hint_executor, ) @@ -348,6 +373,7 @@ fn cairo_run_bitwise_recursion() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -355,7 +381,7 @@ fn cairo_run_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/integration.json"), + include_bytes!("../cairo_programs/integration.json"), &cairo_run_config, &mut hint_executor, ) @@ -363,6 +389,7 @@ fn cairo_run_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_integration_with_alloc_locals() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -370,7 +397,7 @@ fn cairo_run_integration_with_alloc_locals() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/integration_with_alloc_locals.json"), + include_bytes!("../cairo_programs/integration_with_alloc_locals.json"), &cairo_run_config, &mut hint_executor, ) @@ -378,6 +405,7 @@ fn cairo_run_integration_with_alloc_locals() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_arrays() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -385,7 +413,7 @@ fn cairo_run_compare_arrays() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/compare_arrays.json"), + include_bytes!("../cairo_programs/compare_arrays.json"), &cairo_run_config, &mut hint_executor, ) @@ -393,6 +421,7 @@ fn cairo_run_compare_arrays() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_greater_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -400,7 +429,7 @@ fn cairo_run_compare_greater_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/compare_greater_array.json"), + include_bytes!("../cairo_programs/compare_greater_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -408,6 +437,7 @@ fn cairo_run_compare_greater_array() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_lesser_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -415,7 +445,7 @@ fn cairo_run_compare_lesser_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/compare_lesser_array.json"), + include_bytes!("../cairo_programs/compare_lesser_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -423,6 +453,7 @@ fn cairo_run_compare_lesser_array() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_le_felt_hint() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -430,7 +461,7 @@ fn cairo_run_assert_le_felt_hint() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_le_felt_hint.json"), + include_bytes!("../cairo_programs/assert_le_felt_hint.json"), &cairo_run_config, &mut hint_executor, ) @@ -438,6 +469,7 @@ fn cairo_run_assert_le_felt_hint() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_250_bit_element_array() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -445,7 +477,7 @@ fn cairo_run_assert_250_bit_element_array() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_250_bit_element_array.json"), + include_bytes!("../cairo_programs/assert_250_bit_element_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -453,6 +485,7 @@ fn cairo_run_assert_250_bit_element_array() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_abs_value() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -460,7 +493,7 @@ fn cairo_abs_value() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/abs_value_array.json"), + include_bytes!("../cairo_programs/abs_value_array.json"), &cairo_run_config, &mut hint_executor, ) @@ -468,6 +501,7 @@ fn cairo_abs_value() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_compare_different_arrays() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -475,7 +509,7 @@ fn cairo_run_compare_different_arrays() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/compare_different_arrays.json"), + include_bytes!("../cairo_programs/compare_different_arrays.json"), &cairo_run_config, &mut hint_executor, ) @@ -483,6 +517,7 @@ fn cairo_run_compare_different_arrays() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_nn() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -490,7 +525,7 @@ fn cairo_run_assert_nn() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_nn.json"), + include_bytes!("../cairo_programs/assert_nn.json"), &cairo_run_config, &mut hint_executor, ) @@ -498,6 +533,7 @@ fn cairo_run_assert_nn() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_sqrt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -505,7 +541,7 @@ fn cairo_run_sqrt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/sqrt.json"), + include_bytes!("../cairo_programs/sqrt.json"), &cairo_run_config, &mut hint_executor, ) @@ -513,6 +549,7 @@ fn cairo_run_sqrt() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_not_zero() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -520,7 +557,7 @@ fn cairo_run_assert_not_zero() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_not_zero.json"), + include_bytes!("../cairo_programs/assert_not_zero.json"), &cairo_run_config, &mut hint_executor, ) @@ -528,6 +565,7 @@ fn cairo_run_assert_not_zero() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_int() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -535,7 +573,7 @@ fn cairo_run_split_int() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/split_int.json"), + include_bytes!("../cairo_programs/split_int.json"), &cairo_run_config, &mut hint_executor, ) @@ -543,6 +581,7 @@ fn cairo_run_split_int() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_int_big() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -550,7 +589,7 @@ fn cairo_run_split_int_big() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/split_int_big.json"), + include_bytes!("../cairo_programs/split_int_big.json"), &cairo_run_config, &mut hint_executor, ) @@ -558,6 +597,7 @@ fn cairo_run_split_int_big() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_split_felt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -565,7 +605,7 @@ fn cairo_run_split_felt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/split_felt.json"), + include_bytes!("../cairo_programs/split_felt.json"), &cairo_run_config, &mut hint_executor, ) @@ -573,6 +613,7 @@ fn cairo_run_split_felt() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_math_cmp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -580,7 +621,7 @@ fn cairo_run_math_cmp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/math_cmp.json"), + include_bytes!("../cairo_programs/math_cmp.json"), &cairo_run_config, &mut hint_executor, ) @@ -588,6 +629,7 @@ fn cairo_run_math_cmp() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsigned_div_rem() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -595,7 +637,7 @@ fn cairo_run_unsigned_div_rem() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/unsigned_div_rem.json"), + include_bytes!("../cairo_programs/unsigned_div_rem.json"), &cairo_run_config, &mut hint_executor, ) @@ -603,6 +645,7 @@ fn cairo_run_unsigned_div_rem() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_signed_div_rem() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -610,7 +653,7 @@ fn cairo_run_signed_div_rem() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/signed_div_rem.json"), + include_bytes!("../cairo_programs/signed_div_rem.json"), &cairo_run_config, &mut hint_executor, ) @@ -618,6 +661,7 @@ fn cairo_run_signed_div_rem() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_assert_lt_felt() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -625,7 +669,7 @@ fn cairo_run_assert_lt_felt() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/assert_lt_felt.json"), + include_bytes!("../cairo_programs/assert_lt_felt.json"), &cairo_run_config, &mut hint_executor, ) @@ -633,6 +677,7 @@ fn cairo_run_assert_lt_felt() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memcpy() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -640,7 +685,7 @@ fn cairo_run_memcpy() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/memcpy_test.json"), + include_bytes!("../cairo_programs/memcpy_test.json"), &cairo_run_config, &mut hint_executor, ) @@ -648,6 +693,7 @@ fn cairo_run_memcpy() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memset() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -655,7 +701,7 @@ fn cairo_run_memset() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/memset.json"), + include_bytes!("../cairo_programs/memset.json"), &cairo_run_config, &mut hint_executor, ) @@ -663,6 +709,7 @@ fn cairo_run_memset() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_pow() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -670,7 +717,7 @@ fn cairo_run_pow() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/pow.json"), + include_bytes!("../cairo_programs/pow.json"), &cairo_run_config, &mut hint_executor, ) @@ -678,6 +725,7 @@ fn cairo_run_pow() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -685,7 +733,7 @@ fn cairo_run_dict() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict.json"), + include_bytes!("../cairo_programs/dict.json"), &cairo_run_config, &mut hint_executor, ) @@ -693,6 +741,7 @@ fn cairo_run_dict() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_update() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -700,7 +749,7 @@ fn cairo_run_dict_update() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict_update.json"), + include_bytes!("../cairo_programs/dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -708,6 +757,7 @@ fn cairo_run_dict_update() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_uint256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -715,7 +765,7 @@ fn cairo_run_uint256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/uint256.json"), + include_bytes!("../cairo_programs/uint256.json"), &cairo_run_config, &mut hint_executor, ) @@ -723,6 +773,7 @@ fn cairo_run_uint256() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_find_element() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -730,7 +781,7 @@ fn cairo_run_find_element() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/find_element.json"), + include_bytes!("../cairo_programs/find_element.json"), &cairo_run_config, &mut hint_executor, ) @@ -738,6 +789,7 @@ fn cairo_run_find_element() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_search_sorted_lower() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -745,7 +797,7 @@ fn cairo_run_search_sorted_lower() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/search_sorted_lower.json"), + include_bytes!("../cairo_programs/search_sorted_lower.json"), &cairo_run_config, &mut hint_executor, ) @@ -753,6 +805,7 @@ fn cairo_run_search_sorted_lower() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_usort() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -760,7 +813,7 @@ fn cairo_run_usort() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/usort.json"), + include_bytes!("../cairo_programs/usort.json"), &cairo_run_config, &mut hint_executor, ) @@ -768,6 +821,7 @@ fn cairo_run_usort() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_usort_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -775,7 +829,7 @@ fn cairo_run_usort_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_usort.json"), + include_bytes!("../cairo_programs/bad_programs/bad_usort.json"), &cairo_run_config, &mut hint_executor, ); @@ -788,6 +842,7 @@ fn cairo_run_usort_bad() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_write_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -795,7 +850,7 @@ fn cairo_run_dict_write_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; assert!(cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_dict_new.json"), + include_bytes!("../cairo_programs/bad_programs/bad_dict_new.json"), &cairo_run_config, &mut hint_executor, ) @@ -806,7 +861,7 @@ fn cairo_run_dict_write_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_dict_new.json"), + include_bytes!("../cairo_programs/bad_programs/bad_dict_new.json"), &cairo_run_config, &mut hint_executor, ) @@ -818,6 +873,7 @@ fn cairo_run_dict_write_bad() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_update_bad() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -825,7 +881,7 @@ fn cairo_run_dict_update_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; assert!(cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_dict_update.json"), + include_bytes!("../cairo_programs/bad_programs/bad_dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -836,7 +892,7 @@ fn cairo_run_dict_update_bad() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/bad_dict_update.json"), + include_bytes!("../cairo_programs/bad_programs/bad_dict_update.json"), &cairo_run_config, &mut hint_executor, ) @@ -847,6 +903,7 @@ fn cairo_run_dict_update_bad() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_squash_dict() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -854,7 +911,7 @@ fn cairo_run_squash_dict() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/squash_dict.json"), + include_bytes!("../cairo_programs/squash_dict.json"), &cairo_run_config, &mut hint_executor, ) @@ -862,6 +919,7 @@ fn cairo_run_squash_dict() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_squash() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -869,7 +927,7 @@ fn cairo_run_dict_squash() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict_squash.json"), + include_bytes!("../cairo_programs/dict_squash.json"), &cairo_run_config, &mut hint_executor, ) @@ -877,6 +935,7 @@ fn cairo_run_dict_squash() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_set_add() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -884,7 +943,7 @@ fn cairo_run_set_add() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/set_add.json"), + include_bytes!("../cairo_programs/set_add.json"), &cairo_run_config, &mut hint_executor, ) @@ -892,6 +951,7 @@ fn cairo_run_set_add() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -899,7 +959,7 @@ fn cairo_run_secp() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/secp.json"), + include_bytes!("../cairo_programs/secp.json"), &cairo_run_config, &mut hint_executor, ) @@ -907,6 +967,7 @@ fn cairo_run_secp() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_signature() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -914,7 +975,7 @@ fn cairo_run_signature() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/signature.json"), + include_bytes!("../cairo_programs/signature.json"), &cairo_run_config, &mut hint_executor, ) @@ -922,6 +983,7 @@ fn cairo_run_signature() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp_ec() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -929,7 +991,7 @@ fn cairo_run_secp_ec() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/secp_ec.json"), + include_bytes!("../cairo_programs/secp_ec.json"), &cairo_run_config, &mut hint_executor, ) @@ -937,6 +999,7 @@ fn cairo_run_secp_ec() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_hello_world_hash() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -944,7 +1007,7 @@ fn cairo_run_blake2s_hello_world_hash() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/blake2s_hello_world_hash.json"), + include_bytes!("../cairo_programs/blake2s_hello_world_hash.json"), &cairo_run_config, &mut hint_executor, ) @@ -952,6 +1015,7 @@ fn cairo_run_blake2s_hello_world_hash() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_finalize_blake2s() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -959,13 +1023,14 @@ fn cairo_run_finalize_blake2s() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/finalize_blake2s.json"), + include_bytes!("../cairo_programs/finalize_blake2s.json"), &cairo_run_config, &mut hint_executor, ) .expect("Couldn't run program"); } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsafe_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -973,7 +1038,7 @@ fn cairo_run_unsafe_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/unsafe_keccak.json"), + include_bytes!("../cairo_programs/unsafe_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -981,6 +1046,7 @@ fn cairo_run_unsafe_keccak() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_felts() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -988,7 +1054,7 @@ fn cairo_run_blake2s_felts() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/blake2s_felts.json"), + include_bytes!("../cairo_programs/blake2s_felts.json"), &cairo_run_config, &mut hint_executor, ) @@ -996,6 +1062,7 @@ fn cairo_run_blake2s_felts() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_unsafe_keccak_finalize() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1003,7 +1070,7 @@ fn cairo_run_unsafe_keccak_finalize() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/unsafe_keccak_finalize.json"), + include_bytes!("../cairo_programs/unsafe_keccak_finalize.json"), &cairo_run_config, &mut hint_executor, ) @@ -1011,6 +1078,7 @@ fn cairo_run_unsafe_keccak_finalize() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_add_uint256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1018,7 +1086,7 @@ fn cairo_run_keccak_add_uint256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/keccak_add_uint256.json"), + include_bytes!("../cairo_programs/keccak_add_uint256.json"), &cairo_run_config, &mut hint_executor, ) @@ -1026,6 +1094,7 @@ fn cairo_run_keccak_add_uint256() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_private_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1033,7 +1102,7 @@ fn cairo_run_private_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/_keccak.json"), + include_bytes!("../cairo_programs/_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -1041,6 +1110,7 @@ fn cairo_run_private_keccak() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_copy_inputs() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1048,7 +1118,7 @@ fn cairo_run_keccak_copy_inputs() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/keccak_copy_inputs.json"), + include_bytes!("../cairo_programs/keccak_copy_inputs.json"), &cairo_run_config, &mut hint_executor, ) @@ -1056,6 +1126,7 @@ fn cairo_run_keccak_copy_inputs() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_finalize_keccak() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1063,7 +1134,7 @@ fn cairo_run_finalize_keccak() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/cairo_finalize_keccak.json"), + include_bytes!("../cairo_programs/cairo_finalize_keccak.json"), &cairo_run_config, &mut hint_executor, ) @@ -1071,6 +1142,7 @@ fn cairo_run_finalize_keccak() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_operations_with_data() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1078,7 +1150,7 @@ fn cairo_run_operations_with_data() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/operations_with_data_structures.json"), + include_bytes!("../cairo_programs/operations_with_data_structures.json"), &cairo_run_config, &mut hint_executor, ) @@ -1086,6 +1158,7 @@ fn cairo_run_operations_with_data() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_sha256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1093,7 +1166,7 @@ fn cairo_run_sha256() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/sha256.json"), + include_bytes!("../cairo_programs/sha256.json"), &cairo_run_config, &mut hint_executor, ) @@ -1101,6 +1174,7 @@ fn cairo_run_sha256() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_math_cmp_and_pow_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1108,7 +1182,7 @@ fn cairo_run_math_cmp_and_pow_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/math_cmp_and_pow_integration_tests.json"), + include_bytes!("../cairo_programs/math_cmp_and_pow_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1116,6 +1190,7 @@ fn cairo_run_math_cmp_and_pow_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_uint256_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1123,7 +1198,7 @@ fn cairo_run_uint256_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/uint256_integration_tests.json"), + include_bytes!("../cairo_programs/uint256_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1131,6 +1206,7 @@ fn cairo_run_uint256_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_set_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1138,7 +1214,7 @@ fn cairo_run_set_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/set_integration_tests.json"), + include_bytes!("../cairo_programs/set_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1146,6 +1222,7 @@ fn cairo_run_set_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_memory_module_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1153,7 +1230,7 @@ fn cairo_run_memory_module_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/memory_integration_tests.json"), + include_bytes!("../cairo_programs/memory_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1161,6 +1238,7 @@ fn cairo_run_memory_module_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1168,7 +1246,7 @@ fn cairo_run_dict_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict_integration_tests.json"), + include_bytes!("../cairo_programs/dict_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1176,6 +1254,7 @@ fn cairo_run_dict_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_secp_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1183,7 +1262,7 @@ fn cairo_run_secp_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/secp_integration_tests.json"), + include_bytes!("../cairo_programs/secp_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1191,6 +1270,7 @@ fn cairo_run_secp_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_keccak_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1198,7 +1278,7 @@ fn cairo_run_keccak_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/keccak_integration_tests.json"), + include_bytes!("../cairo_programs/keccak_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1206,6 +1286,7 @@ fn cairo_run_keccak_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_blake2s_integration() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1213,7 +1294,7 @@ fn cairo_run_blake2s_integration() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/blake2s_integration_tests.json"), + include_bytes!("../cairo_programs/blake2s_integration_tests.json"), &cairo_run_config, &mut hint_executor, ) @@ -1221,6 +1302,7 @@ fn cairo_run_blake2s_integration() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_relocate_segments() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1228,7 +1310,7 @@ fn cairo_run_relocate_segments() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/relocate_segments.json"), + include_bytes!("../cairo_programs/relocate_segments.json"), &cairo_run_config, &mut hint_executor, ) @@ -1236,6 +1318,7 @@ fn cairo_run_relocate_segments() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1243,7 +1326,7 @@ fn cairo_run_error_msg_attr() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/error_msg_attr.json"), + include_bytes!("../cairo_programs/bad_programs/error_msg_attr.json"), &cairo_run_config, &mut hint_executor, ) @@ -1254,6 +1337,7 @@ fn cairo_run_error_msg_attr() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr_ap_based_reference() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1261,17 +1345,22 @@ fn cairo_run_error_msg_attr_ap_based_reference() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/error_msg_attr_tempvar.json"), + include_bytes!("../cairo_programs/bad_programs/error_msg_attr_tempvar.json"), &cairo_run_config, &mut hint_executor, ) .err() .unwrap(); + #[cfg(feature = "std")] assert_eq!(err.to_string(), String::from("Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n assert x = 2;\n ^***********^\n")); + + #[cfg(not(feature = "std"))] + assert_eq!(err.to_string(), String::from("Error message: SafeUint256: addition overflow: {x} (Cannot evaluate ap-based or complex references: ['x'])\ncairo_programs/bad_programs/error_msg_attr_tempvar.cairo:4:9: Error at pc=0:2:\nAn ASSERT_EQ instruction failed: 3 != 2.\n")); } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_error_msg_attr_complex_reference() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1279,7 +1368,7 @@ fn cairo_run_error_msg_attr_complex_reference() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; let err = cairo_run::cairo_run( - Path::new("cairo_programs/bad_programs/error_msg_attr_struct.json"), + include_bytes!("../cairo_programs/bad_programs/error_msg_attr_struct.json"), &cairo_run_config, &mut hint_executor, ) @@ -1289,6 +1378,7 @@ fn cairo_run_error_msg_attr_complex_reference() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_dict_store_cast_pointer() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1296,7 +1386,7 @@ fn cairo_run_dict_store_cast_pointer() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/dict_store_cast_ptr.json"), + include_bytes!("../cairo_programs/dict_store_cast_ptr.json"), &cairo_run_config, &mut hint_executor, ) @@ -1304,6 +1394,7 @@ fn cairo_run_dict_store_cast_pointer() { } #[test] +#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn cairo_run_verify_signature_hint() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { @@ -1311,7 +1402,7 @@ fn cairo_run_verify_signature_hint() { ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - Path::new("cairo_programs/common_signature.json"), + include_bytes!("../cairo_programs/common_signature.json"), &cairo_run_config, &mut hint_executor, ) From 6790b25486243176f8e404aed5a14ddf872d17a0 Mon Sep 17 00:00:00 2001 From: fmoletta <99273364+fmoletta@users.noreply.github.com> Date: Wed, 15 Mar 2023 19:23:53 +0200 Subject: [PATCH 08/15] Fix relative paths in `compare_vm_state` script (#898) * Fix relative path in compare_vm_state script * Update compare_vm_state.sh * Temporary fix for dependency * Fix iai workflow --- .github/workflows/bench.yml | 2 +- .github/workflows/bench_pull_request.yml | 2 +- .github/workflows/iai_main.yml | 2 +- .github/workflows/iai_pr.yml | 4 ++-- .github/workflows/rust.yml | 2 +- src/tests/compare_vm_state.sh | 4 ++-- 6 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml index 2503d5e7a3..88bb7132c6 100644 --- a/.github/workflows/bench.yml +++ b/.github/workflows/bench.yml @@ -26,7 +26,7 @@ jobs: with: python-version: '3.9' - name: Install test dependencies - run: pip install ecdsa fastecdsa sympy cairo-lang + run: pip install ecdsa fastecdsa sympy typeguard==2.13.0 cairo-lang - name: Run benchmark run: make benchmark-action - name: Store benchmark result diff --git a/.github/workflows/bench_pull_request.yml b/.github/workflows/bench_pull_request.yml index 5977936ad7..ec380c72cd 100644 --- a/.github/workflows/bench_pull_request.yml +++ b/.github/workflows/bench_pull_request.yml @@ -20,7 +20,7 @@ jobs: with: python-version: '3.9' - name: Install test dependencies - run: pip install ecdsa fastecdsa sympy cairo-lang + run: pip install ecdsa fastecdsa sympy typeguard==2.13.0 cairo-lang - name: Run benchmark run: make benchmark-action - name: Store benchmark result diff --git a/.github/workflows/iai_main.yml b/.github/workflows/iai_main.yml index 1537e6394b..cb8ec0d0ee 100644 --- a/.github/workflows/iai_main.yml +++ b/.github/workflows/iai_main.yml @@ -20,7 +20,7 @@ jobs: python-version: '3.9' - name: Install test dependencies run: | - pip install ecdsa fastecdsa sympy cairo-lang + pip install ecdsa fastecdsa sympy typeguard==2.13.0 cairo-lang sudo apt update sudo apt install -y valgrind - uses: actions/checkout@v3 diff --git a/.github/workflows/iai_pr.yml b/.github/workflows/iai_pr.yml index 370acea0d2..d8efc4dba3 100644 --- a/.github/workflows/iai_pr.yml +++ b/.github/workflows/iai_pr.yml @@ -20,7 +20,7 @@ jobs: python-version: '3.9' - name: Install test dependencies run: | - pip install ecdsa fastecdsa sympy cairo-lang + pip install ecdsa fastecdsa sympy typeguard==2.13.0 cairo-lang sudo apt update sudo apt install -y valgrind - uses: actions/checkout@v3 @@ -55,7 +55,7 @@ jobs: python-version: '3.9' - name: Install test dependencies run: | - pip install ecdsa fastecdsa sympy cairo-lang + pip install ecdsa fastecdsa sympy typeguard==2.13.0 cairo-lang sudo apt update sudo apt install -y valgrind - uses: actions/checkout@v3 diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 49d668e8c2..6cebda07a2 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -63,7 +63,7 @@ jobs: - name: Restore timestamps uses: chetan/git-restore-mtime-action@v1 - name: Install dependencies - run: pip install ecdsa fastecdsa sympy cairo-lang + run: pip install ecdsa fastecdsa sympy typeguard==2.13.0 cairo-lang - name: Run tests run: make -j test - name: Run tests no_std diff --git a/src/tests/compare_vm_state.sh b/src/tests/compare_vm_state.sh index 5c15a37cf4..61a7d3032e 100755 --- a/src/tests/compare_vm_state.sh +++ b/src/tests/compare_vm_state.sh @@ -1,6 +1,6 @@ #!/usr/bin/env sh -tests_path="../cairo_programs" +tests_path="../../cairo_programs" exit_code=0 trace=false memory=false @@ -13,7 +13,7 @@ for i in $@; do ;; "memory") memory=true ;; - "proof_mode") tests_path="../cairo_programs/proof_programs" + "proof_mode") tests_path="../../cairo_programs/proof_programs" ;; *) ;; From 6fd359cd8972d4e5145fdf1a2b7d157478b9dd48 Mon Sep 17 00:00:00 2001 From: Mario Rugiero Date: Wed, 15 Mar 2023 17:52:33 -0300 Subject: [PATCH 09/15] Remove leftover commented code (#901) --- src/cairo_run.rs | 27 --------------------------- 1 file changed, 27 deletions(-) diff --git a/src/cairo_run.rs b/src/cairo_run.rs index 0b04800342..57c61026ad 100644 --- a/src/cairo_run.rs +++ b/src/cairo_run.rs @@ -86,17 +86,6 @@ pub fn write_encoded_trace( relocated_trace: &[crate::vm::trace::trace_entry::RelocatedTraceEntry], dest: &mut impl Writer, ) -> Result<(), EncodeTraceError> { - /* - let mut serialized: [u8; 24] = [0; 24]; - - for (i, entry) in relocated_trace.iter().enumerate() { - serialized[..8].copy_from_slice(&((entry.ap as u64).to_le_bytes())); - serialized[8..16].copy_from_slice(&((entry.fp as u64).to_le_bytes())); - serialized[16..].copy_from_slice(&((entry.pc as u64).to_le_bytes())); - dest.write(&serialized) - .map_err(|e| EncodeTraceError(i, e))?; - } - */ for (i, entry) in relocated_trace.iter().enumerate() { dest.write(&((entry.ap as u64).to_le_bytes())) .map_err(|e| EncodeTraceError(i, e))?; @@ -118,22 +107,6 @@ pub fn write_encoded_memory( relocated_memory: &[Option], dest: &mut impl Writer, ) -> Result<(), EncodeTraceError> { - // initialize bytes vector that will be dumped to file - /* - let mut serialized: [u8; 40] = [0; 40]; - - for (i, memory_cell) in relocated_memory.iter().enumerate() { - match memory_cell { - None => continue, - Some(unwrapped_memory_cell) => { - serialized[..8].copy_from_slice(&(i as u64).to_le_bytes()); - serialized[8..].copy_from_slice(&unwrapped_memory_cell.to_le_bytes()); - dest.write(&serialized) - .map_err(|e| EncodeTraceError(i, e))?; - } - } - } - */ for (i, memory_cell) in relocated_memory.iter().enumerate() { match memory_cell { None => continue, From 29e5580ded73f40feddec4e756b5646b875f4699 Mon Sep 17 00:00:00 2001 From: Mario Rugiero Date: Wed, 15 Mar 2023 17:56:15 -0300 Subject: [PATCH 10/15] Rename Felt to Felt252 (#899) --- felt/src/lib.rs | 370 +++++++++--------- src/cairo_run.rs | 8 +- .../builtin_hint_processor/blake2s_utils.rs | 22 +- .../builtin_hint_processor_definition.rs | 28 +- .../cairo_keccak/keccak_hints.rs | 42 +- .../find_element_hint.rs | 68 ++-- .../builtin_hint_processor/hint_utils.rs | 6 +- .../builtin_hint_processor/keccak_utils.rs | 14 +- .../builtin_hint_processor/math_utils.rs | 141 +++---- .../memcpy_hint_utils.rs | 14 +- .../builtin_hint_processor/memset_utils.rs | 18 +- .../builtin_hint_processor/pow_utils.rs | 14 +- .../secp/bigint_utils.rs | 30 +- .../builtin_hint_processor/secp/ec_utils.rs | 128 +++--- .../secp/field_utils.rs | 150 +++---- .../builtin_hint_processor/secp/secp_utils.rs | 14 +- .../builtin_hint_processor/secp/signature.rs | 56 +-- .../builtin_hint_processor/set.rs | 14 +- .../builtin_hint_processor/sha256_utils.rs | 16 +- .../squash_dict_utils.rs | 212 +++++----- .../builtin_hint_processor/uint256_utils.rs | 46 +-- .../builtin_hint_processor/usort.rs | 22 +- .../hint_processor_definition.rs | 4 +- src/hint_processor/hint_processor_utils.rs | 22 +- src/math_utils.rs | 20 +- src/serde/deserialize_program.rs | 66 ++-- src/serde/deserialize_utils.rs | 18 +- src/types/errors/math_errors.rs | 28 +- src/types/exec_scope.rs | 48 +-- src/types/instruction.rs | 21 +- src/types/program.rs | 16 +- src/types/relocatable.rs | 144 ++++--- src/utils.rs | 30 +- src/vm/context/run_context.rs | 4 +- src/vm/decoding/decoder.rs | 6 +- src/vm/errors/hint_errors.rs | 50 +-- src/vm/errors/memory_errors.rs | 6 +- src/vm/errors/runner_errors.rs | 8 +- src/vm/errors/vm_errors.rs | 4 +- src/vm/hooks.rs | 16 +- src/vm/runners/builtin_runner/bitwise.rs | 8 +- src/vm/runners/builtin_runner/ec_op.rs | 42 +- src/vm/runners/builtin_runner/hash.rs | 4 +- src/vm/runners/builtin_runner/keccak.rs | 8 +- src/vm/runners/builtin_runner/range_check.rs | 15 +- src/vm/runners/builtin_runner/signature.rs | 4 +- src/vm/runners/cairo_runner.rs | 115 +++--- src/vm/security.rs | 26 +- src/vm/vm_core.rs | 319 +++++++-------- src/vm/vm_memory/memory.rs | 86 ++-- src/vm/vm_memory/memory_segments.rs | 22 +- 51 files changed, 1334 insertions(+), 1259 deletions(-) diff --git a/felt/src/lib.rs b/felt/src/lib.rs index ffc122fdab..733a93a208 100644 --- a/felt/src/lib.rs +++ b/felt/src/lib.rs @@ -52,35 +52,35 @@ pub(crate) trait FeltOps { fn to_str_radix(&self, radix: u32) -> String; #[deprecated] - /// Converts [`Felt`] into a [`BigInt`] number in the range: `(- FIELD / 2, FIELD / 2)`. + /// Converts [`Felt252`] into a [`BigInt`] number in the range: `(- FIELD / 2, FIELD / 2)`. /// /// # Examples /// /// ``` - /// # use crate::cairo_felt::Felt; + /// # use crate::cairo_felt::Felt252; /// # use num_bigint::BigInt; /// # use num_traits::Bounded; - /// let positive = Felt::new(5); + /// let positive = Felt252::new(5); /// assert_eq!(positive.to_bigint(), Into::::into(5)); /// - /// let negative = Felt::max_value(); + /// let negative = Felt252::max_value(); /// assert_eq!(negative.to_bigint(), Into::::into(-1)); /// ``` fn to_bigint(&self) -> BigInt; #[deprecated] - /// Converts [`Felt`] into a [`BigUint`] number. + /// Converts [`Felt252`] into a [`BigUint`] number. /// /// # Examples /// /// ``` - /// # use crate::cairo_felt::Felt; + /// # use crate::cairo_felt::Felt252; /// # use num_bigint::BigUint; /// # use num_traits::{Num, Bounded}; - /// let positive = Felt::new(5); + /// let positive = Felt252::new(5); /// assert_eq!(positive.to_biguint(), Into::::into(5_u32)); /// - /// let negative = Felt::max_value(); + /// let negative = Felt252::max_value(); /// assert_eq!(negative.to_biguint(), BigUint::from_str_radix("800000000000011000000000000000000000000000000000000000000000000", 16).unwrap()); /// ``` fn to_biguint(&self) -> BigUint; @@ -95,10 +95,10 @@ pub(crate) trait FeltOps { #[macro_export] macro_rules! felt_str { ($val: expr) => { - felt::Felt::parse_bytes($val.as_bytes(), 10_u32).expect("Couldn't parse bytes") + felt::Felt252::parse_bytes($val.as_bytes(), 10_u32).expect("Couldn't parse bytes") }; ($val: expr, $opt: expr) => { - felt::Felt::parse_bytes($val.as_bytes(), $opt as u32).expect("Couldn't parse bytes") + felt::Felt252::parse_bytes($val.as_bytes(), $opt as u32).expect("Couldn't parse bytes") }; } @@ -106,13 +106,13 @@ macro_rules! felt_str { pub struct ParseFeltError; #[derive(Eq, Hash, PartialEq, PartialOrd, Ord, Clone, Deserialize, Default, Serialize)] -pub struct Felt { +pub struct Felt252 { value: FeltBigInt, } macro_rules! from_num { ($type:ty) => { - impl From<$type> for Felt { + impl From<$type> for Felt252 { fn from(value: $type) -> Self { Self { value: value.into(), @@ -139,11 +139,11 @@ from_num!(&BigInt); from_num!(BigUint); from_num!(&BigUint); -impl Felt { - pub fn new>(value: T) -> Self { +impl Felt252 { + pub fn new>(value: T) -> Self { value.into() } - pub fn modpow(&self, exponent: &Felt, modulus: &Felt) -> Self { + pub fn modpow(&self, exponent: &Felt252, modulus: &Felt252) -> Self { Self { value: self.value.modpow(&exponent.value, &modulus.value), } @@ -204,7 +204,7 @@ impl Felt { } } -impl Add for Felt { +impl Add for Felt252 { type Output = Self; fn add(self, rhs: Self) -> Self { Self { @@ -213,8 +213,8 @@ impl Add for Felt { } } -impl<'a> Add for &'a Felt { - type Output = Felt; +impl<'a> Add for &'a Felt252 { + type Output = Felt252; fn add(self, rhs: Self) -> Self::Output { Self::Output { value: &self.value + &rhs.value, @@ -222,7 +222,7 @@ impl<'a> Add for &'a Felt { } } -impl<'a> Add<&'a Felt> for Felt { +impl<'a> Add<&'a Felt252> for Felt252 { type Output = Self; fn add(self, rhs: &Self) -> Self::Output { Self::Output { @@ -231,7 +231,7 @@ impl<'a> Add<&'a Felt> for Felt { } } -impl Add for Felt { +impl Add for Felt252 { type Output = Self; fn add(self, rhs: u32) -> Self { Self { @@ -240,7 +240,7 @@ impl Add for Felt { } } -impl Add for Felt { +impl Add for Felt252 { type Output = Self; fn add(self, rhs: usize) -> Self { Self { @@ -249,8 +249,8 @@ impl Add for Felt { } } -impl<'a> Add for &'a Felt { - type Output = Felt; +impl<'a> Add for &'a Felt252 { + type Output = Felt252; fn add(self, rhs: usize) -> Self::Output { Self::Output { value: &self.value + rhs, @@ -258,28 +258,28 @@ impl<'a> Add for &'a Felt { } } -impl AddAssign for Felt { +impl AddAssign for Felt252 { fn add_assign(&mut self, rhs: Self) { self.value += rhs.value; } } -impl<'a> AddAssign<&'a Felt> for Felt { +impl<'a> AddAssign<&'a Felt252> for Felt252 { fn add_assign(&mut self, rhs: &Self) { self.value += &rhs.value; } } -impl Sum for Felt { +impl Sum for Felt252 { fn sum>(iter: I) -> Self { - iter.fold(Felt::zero(), |mut acc, x| { + iter.fold(Felt252::zero(), |mut acc, x| { acc += x; acc }) } } -impl Neg for Felt { +impl Neg for Felt252 { type Output = Self; fn neg(self) -> Self { Self { @@ -288,8 +288,8 @@ impl Neg for Felt { } } -impl<'a> Neg for &'a Felt { - type Output = Felt; +impl<'a> Neg for &'a Felt252 { + type Output = Felt252; fn neg(self) -> Self::Output { Self::Output { value: (&self.value).neg(), @@ -297,7 +297,7 @@ impl<'a> Neg for &'a Felt { } } -impl Sub for Felt { +impl Sub for Felt252 { type Output = Self; fn sub(self, rhs: Self) -> Self { Self { @@ -306,8 +306,8 @@ impl Sub for Felt { } } -impl<'a> Sub for &'a Felt { - type Output = Felt; +impl<'a> Sub for &'a Felt252 { + type Output = Felt252; fn sub(self, rhs: Self) -> Self::Output { Self::Output { value: &self.value - &rhs.value, @@ -315,7 +315,7 @@ impl<'a> Sub for &'a Felt { } } -impl<'a> Sub<&'a Felt> for Felt { +impl<'a> Sub<&'a Felt252> for Felt252 { type Output = Self; fn sub(self, rhs: &Self) -> Self { Self { @@ -324,8 +324,8 @@ impl<'a> Sub<&'a Felt> for Felt { } } -impl Sub<&Felt> for usize { - type Output = Felt; +impl Sub<&Felt252> for usize { + type Output = Felt252; fn sub(self, rhs: &Self::Output) -> Self::Output { Self::Output { value: self - &rhs.value, @@ -333,19 +333,19 @@ impl Sub<&Felt> for usize { } } -impl SubAssign for Felt { +impl SubAssign for Felt252 { fn sub_assign(&mut self, rhs: Self) { self.value -= rhs.value } } -impl<'a> SubAssign<&'a Felt> for Felt { +impl<'a> SubAssign<&'a Felt252> for Felt252 { fn sub_assign(&mut self, rhs: &Self) { self.value -= &rhs.value; } } -impl Sub for Felt { +impl Sub for Felt252 { type Output = Self; fn sub(self, rhs: u32) -> Self { Self { @@ -354,8 +354,8 @@ impl Sub for Felt { } } -impl<'a> Sub for &'a Felt { - type Output = Felt; +impl<'a> Sub for &'a Felt252 { + type Output = Felt252; fn sub(self, rhs: u32) -> Self::Output { Self::Output { value: &self.value - rhs, @@ -363,7 +363,7 @@ impl<'a> Sub for &'a Felt { } } -impl Sub for Felt { +impl Sub for Felt252 { type Output = Self; fn sub(self, rhs: usize) -> Self { Self { @@ -372,7 +372,7 @@ impl Sub for Felt { } } -impl Mul for Felt { +impl Mul for Felt252 { type Output = Self; fn mul(self, rhs: Self) -> Self { Self { @@ -381,8 +381,8 @@ impl Mul for Felt { } } -impl<'a> Mul for &'a Felt { - type Output = Felt; +impl<'a> Mul for &'a Felt252 { + type Output = Felt252; fn mul(self, rhs: Self) -> Self::Output { Self::Output { value: &self.value * &rhs.value, @@ -390,7 +390,7 @@ impl<'a> Mul for &'a Felt { } } -impl<'a> Mul<&'a Felt> for Felt { +impl<'a> Mul<&'a Felt252> for Felt252 { type Output = Self; fn mul(self, rhs: &Self) -> Self { Self { @@ -399,13 +399,13 @@ impl<'a> Mul<&'a Felt> for Felt { } } -impl<'a> MulAssign<&'a Felt> for Felt { +impl<'a> MulAssign<&'a Felt252> for Felt252 { fn mul_assign(&mut self, rhs: &Self) { self.value *= &rhs.value; } } -impl Pow for Felt { +impl Pow for Felt252 { type Output = Self; fn pow(self, rhs: u32) -> Self { Self { @@ -414,8 +414,8 @@ impl Pow for Felt { } } -impl<'a> Pow for &'a Felt { - type Output = Felt; +impl<'a> Pow for &'a Felt252 { + type Output = Felt252; fn pow(self, rhs: u32) -> Self::Output { Self::Output { value: (&self.value).pow(rhs), @@ -423,7 +423,7 @@ impl<'a> Pow for &'a Felt { } } -impl Div for Felt { +impl Div for Felt252 { type Output = Self; fn div(self, rhs: Self) -> Self { Self { @@ -432,8 +432,8 @@ impl Div for Felt { } } -impl<'a> Div for &'a Felt { - type Output = Felt; +impl<'a> Div for &'a Felt252 { + type Output = Felt252; fn div(self, rhs: Self) -> Self::Output { Self::Output { value: &self.value / &rhs.value, @@ -441,8 +441,8 @@ impl<'a> Div for &'a Felt { } } -impl<'a> Div for &'a Felt { - type Output = Felt; +impl<'a> Div for &'a Felt252 { + type Output = Felt252; fn div(self, rhs: Self::Output) -> Self::Output { Self::Output { value: &self.value / rhs.value, @@ -450,7 +450,7 @@ impl<'a> Div for &'a Felt { } } -impl Rem for Felt { +impl Rem for Felt252 { type Output = Self; fn rem(self, rhs: Self) -> Self { Self { @@ -459,7 +459,7 @@ impl Rem for Felt { } } -impl<'a> Rem<&'a Felt> for Felt { +impl<'a> Rem<&'a Felt252> for Felt252 { type Output = Self; fn rem(self, rhs: &Self) -> Self { Self { @@ -468,7 +468,7 @@ impl<'a> Rem<&'a Felt> for Felt { } } -impl Zero for Felt { +impl Zero for Felt252 { fn zero() -> Self { Self { value: FeltBigInt::zero(), @@ -480,7 +480,7 @@ impl Zero for Felt { } } -impl One for Felt { +impl One for Felt252 { fn one() -> Self { Self { value: FeltBigInt::one(), @@ -492,7 +492,7 @@ impl One for Felt { } } -impl Bounded for Felt { +impl Bounded for Felt252 { fn min_value() -> Self { Self { value: FeltBigInt::min_value(), @@ -506,7 +506,7 @@ impl Bounded for Felt { } } -impl Num for Felt { +impl Num for Felt252 { type FromStrRadixErr = ParseFeltError; fn from_str_radix(string: &str, radix: u32) -> Result { Ok(Self { @@ -515,7 +515,7 @@ impl Num for Felt { } } -impl Integer for Felt { +impl Integer for Felt252 { fn div_floor(&self, rhs: &Self) -> Self { Self { value: self.value.div_floor(&rhs.value), @@ -562,7 +562,7 @@ impl Integer for Felt { } } -impl Signed for Felt { +impl Signed for Felt252 { fn abs(&self) -> Self { Self { value: self.value.abs(), @@ -590,7 +590,7 @@ impl Signed for Felt { } } -impl Shl for Felt { +impl Shl for Felt252 { type Output = Self; fn shl(self, rhs: u32) -> Self { Self { @@ -599,8 +599,8 @@ impl Shl for Felt { } } -impl<'a> Shl for &'a Felt { - type Output = Felt; +impl<'a> Shl for &'a Felt252 { + type Output = Felt252; fn shl(self, rhs: u32) -> Self::Output { Self::Output { value: &self.value << rhs, @@ -608,7 +608,7 @@ impl<'a> Shl for &'a Felt { } } -impl Shl for Felt { +impl Shl for Felt252 { type Output = Self; fn shl(self, rhs: usize) -> Self { Self { @@ -617,8 +617,8 @@ impl Shl for Felt { } } -impl<'a> Shl for &'a Felt { - type Output = Felt; +impl<'a> Shl for &'a Felt252 { + type Output = Felt252; fn shl(self, rhs: usize) -> Self::Output { Self::Output { value: &self.value << rhs, @@ -626,7 +626,7 @@ impl<'a> Shl for &'a Felt { } } -impl Shr for Felt { +impl Shr for Felt252 { type Output = Self; fn shr(self, rhs: u32) -> Self { Self { @@ -635,8 +635,8 @@ impl Shr for Felt { } } -impl<'a> Shr for &'a Felt { - type Output = Felt; +impl<'a> Shr for &'a Felt252 { + type Output = Felt252; fn shr(self, rhs: u32) -> Self::Output { Self::Output { value: &self.value >> rhs, @@ -644,14 +644,14 @@ impl<'a> Shr for &'a Felt { } } -impl ShrAssign for Felt { +impl ShrAssign for Felt252 { fn shr_assign(&mut self, rhs: usize) { self.value >>= rhs } } -impl<'a> BitAnd for &'a Felt { - type Output = Felt; +impl<'a> BitAnd for &'a Felt252 { + type Output = Felt252; fn bitand(self, rhs: Self) -> Self::Output { Self::Output { value: &self.value & &rhs.value, @@ -659,7 +659,7 @@ impl<'a> BitAnd for &'a Felt { } } -impl<'a> BitAnd<&'a Felt> for Felt { +impl<'a> BitAnd<&'a Felt252> for Felt252 { type Output = Self; fn bitand(self, rhs: &Self) -> Self { Self { @@ -668,8 +668,8 @@ impl<'a> BitAnd<&'a Felt> for Felt { } } -impl<'a> BitAnd for &'a Felt { - type Output = Felt; +impl<'a> BitAnd for &'a Felt252 { + type Output = Felt252; fn bitand(self, rhs: Self::Output) -> Self::Output { Self::Output { value: &self.value & rhs.value, @@ -677,8 +677,8 @@ impl<'a> BitAnd for &'a Felt { } } -impl<'a> BitOr for &'a Felt { - type Output = Felt; +impl<'a> BitOr for &'a Felt252 { + type Output = Felt252; fn bitor(self, rhs: Self) -> Self::Output { Self::Output { value: &self.value | &rhs.value, @@ -686,8 +686,8 @@ impl<'a> BitOr for &'a Felt { } } -impl<'a> BitXor for &'a Felt { - type Output = Felt; +impl<'a> BitXor for &'a Felt252 { + type Output = Felt252; fn bitxor(self, rhs: Self) -> Self::Output { Self::Output { value: &self.value ^ &rhs.value, @@ -695,7 +695,7 @@ impl<'a> BitXor for &'a Felt { } } -impl ToPrimitive for Felt { +impl ToPrimitive for Felt252 { fn to_u64(&self) -> Option { self.value.to_u64() } @@ -705,7 +705,7 @@ impl ToPrimitive for Felt { } } -impl FromPrimitive for Felt { +impl FromPrimitive for Felt252 { fn from_u64(n: u64) -> Option { FeltBigInt::from_u64(n).map(|n| Self { value: n }) } @@ -715,13 +715,13 @@ impl FromPrimitive for Felt { } } -impl fmt::Display for Felt { +impl fmt::Display for Felt252 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.value) } } -impl fmt::Debug for Felt { +impl fmt::Debug for Felt252 { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.value) } @@ -844,7 +844,7 @@ macro_rules! assert_felt_impl { assert_felt_methods!(FeltBigInt); assert_felt_impl!(FeltBigInt); -assert_felt_impl!(Felt); +assert_felt_impl!(Felt252); #[cfg(test)] mod test { @@ -862,18 +862,18 @@ mod test { // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a new felt doesn't fall outside the range [0, p]. // In this and some of the following tests, The value of {x} can be either [0] or a very large number, in order to try to overflow the value of {p} and thus ensure the modular arithmetic is working correctly. fn new_in_range(ref x in "(0|[1-9][0-9]*)") { - let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = &Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); prop_assert!(&x.to_biguint() < p); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a felt created using Felt::from_bytes_be doesn't fall outside the range [0, p]. + // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that a felt created using Felt252::from_bytes_be doesn't fall outside the range [0, p]. // In this and some of the following tests, The value of {x} can be either [0] or a very large number, in order to try to overflow the value of {p} and thus ensure the modular arithmetic is working correctly. fn from_bytes_be_in_range(ref x in "(0|[1-9][0-9]*)") { - let x = &Felt::from_bytes_be(x.as_bytes()); - let max_felt = &Felt::max_value(); + let x = &Felt252::from_bytes_be(x.as_bytes()); + let max_felt = &Felt252::max_value(); prop_assert!(x <= max_felt); } @@ -882,7 +882,7 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 felt values that are randomly generated each time tests are run, that the negative of a felt doesn't fall outside the range [0, p]. fn neg_in_range(ref x in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let neg = -x.clone(); @@ -900,8 +900,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a subtraction between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn sub_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = &Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = &Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = &Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let sub = x - y; @@ -914,8 +914,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a subtraction with assignment between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn sub_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let mut x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); x -= y.clone(); @@ -933,8 +933,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {x} and {y} values that are randomly generated each time tests are run, that a multiplication between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn mul_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = &Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = &Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = &Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let prod = x * y; @@ -947,8 +947,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 pairs of {x} and {y} values that are randomly generated each time tests are run, that a multiplication with assignment between two felts {x} and {y} and doesn't fall outside the range [0, p]. The values of {x} and {y} can be either [0] or a very large number. fn mul_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = &Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let mut x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = &Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); x *= y; @@ -961,8 +961,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 pairs of {x} and {y} values that are randomly generated each time tests are run, that the result of the division of {x} by {y} is the inverse multiplicative of {x} --that is, multiplying the result by {y} returns the original number {x}. The values of {x} and {y} can be either [0] or a very large number. fn div_is_mul_inv(ref x in "(0|[1-9][0-9]*)", ref y in "[1-9][0-9]*") { - let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = &Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = &Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = &Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); prop_assume!(!y.is_zero()); @@ -977,7 +977,7 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the left by {shift_amount} of bits (between 0 and 999) returns a result that is inside of the range [0, p]. fn shift_left_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ - let value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); + let value = Felt252::parse_bytes(value.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let shift_amount:u32 = shift_amount.parse::().unwrap(); @@ -993,7 +993,7 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the right by {shift_amount} of bits (between 0 and 999) returns a result that is inside of the range [0, p]. fn shift_right_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ - let value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); + let value = Felt252::parse_bytes(value.as_bytes(), 10).unwrap(); let shift_amount:u32 = shift_amount.parse::().unwrap(); let result = (value >> shift_amount).to_biguint(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); @@ -1006,7 +1006,7 @@ mod test { // Property-based test that ensures, for 100 {value}s that are randomly generated each time tests are run, that performing a bit shift to the right by {shift_amount} of bits (between 0 and 999), with assignment, returns a result that is inside of the range [0, p]. // "With assignment" means that the result of the operation is autommatically assigned to the variable value, replacing its previous content. fn shift_right_assign_in_range(ref value in "(0|[1-9][0-9]*)", ref shift_amount in "[0-9]{1,3}"){ - let mut value = Felt::parse_bytes(value.as_bytes(), 10).unwrap(); + let mut value = Felt252::parse_bytes(value.as_bytes(), 10).unwrap(); let shift_amount:usize = shift_amount.parse::().unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); value >>= shift_amount; @@ -1018,8 +1018,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitAnd operation between them returns a result that is inside of the range [0, p]. fn bitand_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let result = &x & &y; result.to_biguint(); @@ -1031,8 +1031,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitOr operation between them returns a result that is inside of the range [0, p]. fn bitor_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let result = &x | &y; prop_assert!(result.to_biguint() < p); @@ -1043,8 +1043,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a BitXor operation between them returns a result that is inside of the range [0, p]. fn bitxor_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)"){ - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let result = &x ^ &y; prop_assert!(result.to_biguint() < p); @@ -1055,7 +1055,7 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property-based test that ensures, for 100 values {x} that are randomly generated each time tests are run, that raising {x} to the {y}th power returns a result that is inside of the range [0, p]. fn pow_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "[0-9]{1,2}"){ - let base = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let base = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); let exponent:u32 = y.parse()?; let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); @@ -1073,8 +1073,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Property based test that ensures, for 100 pairs of values {x} and {y} generated at random each time tests are run, that performing a Sum operation between them returns a result that is inside of the range [0, p]. fn sum_in_range(ref x in "[1-9][0-9]*", ref y in "[0-9][0-9]*"){ - let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = &Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = &Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = &Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let result = x + y; @@ -1087,8 +1087,8 @@ mod test { // Property test to check that the remainder of a division between 100 pairs of values {x} and {y},generated at random each time tests are run, falls in the range [0, p]. x and y can either take the value of 0 or a large integer. // In Cairo, the result of x / y is defined to always satisfy the equation (x / y) * y == x, so the remainder is 0 most of the time. fn rem_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let result = x.clone() % y.clone(); @@ -1103,10 +1103,10 @@ mod test { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - // Property based test that ensures, for 100 Felts {x} generated at random each time tests are run, that converting them into the u64 type returns a result that is inside of the range [0, p]. + // Property based test that ensures, for 100 Felt252s {x} generated at random each time tests are run, that converting them into the u64 type returns a result that is inside of the range [0, p]. fn from_u64_and_to_u64_primitive(x in any::()) { - let x_felt:Felt = Felt::from_u64(x).unwrap(); - let x_u64:u64 = Felt::to_u64(&x_felt).unwrap(); + let x_felt:Felt252 = Felt252::from_u64(x).unwrap(); + let x_u64:u64 = Felt252::to_u64(&x_felt).unwrap(); prop_assert_eq!(x, x_u64); } @@ -1115,8 +1115,8 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn from_i64_and_to_i64_primitive(x in any::()) { let x: i64 = x as i64; - let x_felt:Felt = Felt::from_i64(x).unwrap(); - let x_i64:i64 = Felt::to_i64(&x_felt).unwrap(); + let x_felt:Felt252 = Felt252::from_i64(x).unwrap(); + let x_i64:i64 = Felt252::to_i64(&x_felt).unwrap(); prop_assert_eq!(x, x_i64); } @@ -1124,8 +1124,8 @@ mod test { // Property test to check that lcm(x, y) works. Since we're operating in a prime field, lcm // will just be the smaller number. fn lcm_doesnt_panic(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let lcm = x.lcm(&y); prop_assert!(lcm == cmp::max(x, y)); } @@ -1135,22 +1135,22 @@ mod test { // Property test to check that is_multiple_of(x, y) works. Since we're operating in a prime field, is_multiple_of // will always be true fn is_multiple_of_doesnt_panic(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); prop_assert!(x.is_multiple_of(&y)); } #[test] fn divides_doesnt_panic(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); prop_assert!(x.divides(&y)); } #[test] fn gcd_doesnt_panic(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let gcd1 = x.gcd(&y); let gcd2 = y.gcd(&x); prop_assert_eq!(gcd1, gcd2); @@ -1158,13 +1158,13 @@ mod test { #[test] fn is_even(ref x in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); prop_assert_eq!(x.is_even(), x.to_biguint().is_even()); } #[test] fn is_odd(ref x in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); prop_assert_eq!(x.is_odd(), x.to_biguint().is_odd()); } @@ -1176,8 +1176,8 @@ mod test { /// ``` #[test] fn zero_additive_identity(ref x in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let zero = Felt::zero(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let zero = Felt252::zero(); prop_assert_eq!(&x, &(&x + &zero)); prop_assert_eq!(&x, &(&zero + &x)); } @@ -1190,35 +1190,35 @@ mod test { /// ``` #[test] fn one_multiplicative_identity(ref x in "(0|[1-9][0-9]*)") { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let one = Felt::one(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let one = Felt252::one(); prop_assert_eq!(&x, &(&x * &one)); prop_assert_eq!(&x, &(&one * &x)); } #[test] fn non_zero_felt_is_always_positive(ref x in FELT_NON_ZERO_PATTERN) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); prop_assert!(x.is_positive()) } #[test] fn felt_is_never_negative(ref x in FELT_PATTERN) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); prop_assert!(!x.is_negative()) } #[test] fn non_zero_felt_signum_is_always_one(ref x in FELT_NON_ZERO_PATTERN) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let one = Felt::one(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let one = Felt252::one(); prop_assert_eq!(x.signum(), one) } #[test] fn sub_abs(ref x in FELT_PATTERN, ref y in FELT_PATTERN) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let expected_abs_sub = if x > y {&x - &y} else {&y - &x}; @@ -1227,17 +1227,17 @@ mod test { #[test] fn abs(ref x in FELT_PATTERN) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); prop_assert_eq!(&x, &x.abs()) } #[test] fn modpow_in_range(ref x in FELT_PATTERN, ref y in FELT_PATTERN) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = &Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = &Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); - let p_felt = Felt::max_value(); + let p_felt = Felt252::max_value(); let modpow = x.modpow(y, &p_felt).to_biguint(); prop_assert!(modpow < p, "{}", modpow); @@ -1245,7 +1245,7 @@ mod test { #[test] fn sqrt_in_range(ref x in FELT_PATTERN) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let sqrt = x.sqrt().to_biguint(); @@ -1254,13 +1254,13 @@ mod test { #[test] fn sqrt_is_inv_square(ref x in FELT_PATTERN) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); prop_assert_eq!((&x * &x).sqrt(), x); } #[test] fn add_u32_in_range(ref x in FELT_PATTERN, y in any::()) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let x_add_y = (x + y).to_biguint(); prop_assert!(x_add_y < p, "{}", x_add_y); @@ -1268,14 +1268,14 @@ mod test { #[test] fn add_u32_is_inv_sub(ref x in FELT_PATTERN, y in any::()) { - let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = &Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); let expected_y = (x.clone() + y - x).to_u32().unwrap(); prop_assert_eq!(expected_y, y, "{}", expected_y); } #[test] fn sub_u32_in_range(ref x in FELT_PATTERN, y in any::()) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let x_sub_y = (x - y).to_biguint(); prop_assert!(x_sub_y < p, "{}", x_sub_y); @@ -1283,13 +1283,13 @@ mod test { #[test] fn sub_u32_is_inv_add(ref x in FELT_NON_ZERO_PATTERN, y in any::()) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); prop_assert_eq!(x.clone() - y + y, x) } #[test] fn sub_uszie_in_range(ref x in FELT_PATTERN, y in any::()) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); let p = BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let x_sub_y = (x - y).to_biguint(); prop_assert!(x_sub_y < p, "{}", x_sub_y); @@ -1297,14 +1297,14 @@ mod test { #[test] fn sub_usize_is_inv_add(ref x in FELT_PATTERN, y in any::()) { - let x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); + let x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); prop_assert_eq!(x.clone() - y + y, x) } #[test] fn add_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = &Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = &Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = &Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let sub = x + y; @@ -1314,8 +1314,8 @@ mod test { #[test] fn add_is_inv_sub(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let x = &Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = &Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let x = &Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = &Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let expected_y = x + y - x; prop_assert_eq!(&expected_y, y, "{}", y); @@ -1323,8 +1323,8 @@ mod test { #[test] fn add_assign_in_range(ref x in "(0|[1-9][0-9]*)", ref y in "(0|[1-9][0-9]*)") { - let mut x = Felt::parse_bytes(x.as_bytes(), 10).unwrap(); - let y = Felt::parse_bytes(y.as_bytes(), 10).unwrap(); + let mut x = Felt252::parse_bytes(x.as_bytes(), 10).unwrap(); + let y = Felt252::parse_bytes(y.as_bytes(), 10).unwrap(); let p = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); x += y.clone(); @@ -1342,9 +1342,9 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of adding two zeroes is zero fn sum_zeros_in_range() { - let x = Felt::new(0); - let y = Felt::new(0); - let z = Felt::new(0); + let x = Felt252::new(0); + let y = Felt252::new(0); + let z = Felt252::new(0); assert_eq!(x + y, z) } @@ -1352,9 +1352,9 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of multiplying two zeroes is zero fn mul_zeros_in_range() { - let x = Felt::new(0); - let y = Felt::new(0); - let z = Felt::new(0); + let x = Felt252::new(0); + let y = Felt252::new(0); + let z = Felt252::new(0); assert_eq!(x * y, z) } @@ -1362,9 +1362,9 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of performing a bit and operation between zeroes is zero fn bit_and_zeros_in_range() { - let x = Felt::new(0); - let y = Felt::new(0); - let z = Felt::new(0); + let x = Felt252::new(0); + let y = Felt252::new(0); + let z = Felt252::new(0); assert_eq!(&x & &y, z) } @@ -1372,9 +1372,9 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of perfforming a bit or operation between zeroes is zero fn bit_or_zeros_in_range() { - let x = Felt::new(0); - let y = Felt::new(0); - let z = Felt::new(0); + let x = Felt252::new(0); + let y = Felt252::new(0); + let z = Felt252::new(0); assert_eq!(&x | &y, z) } @@ -1382,42 +1382,42 @@ mod test { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] // Checks that the result of perfforming a bit xor operation between zeroes is zero fn bit_xor_zeros_in_range() { - let x = Felt::new(0); - let y = Felt::new(0); - let z = Felt::new(0); + let x = Felt252::new(0); + let y = Felt252::new(0); + let z = Felt252::new(0); assert_eq!(&x ^ &y, z) } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - // Tests that the maximum value a Felt can take is equal to (prime - 1) + // Tests that the maximum value a Felt252 can take is equal to (prime - 1) fn upper_bound() { let prime = &BigUint::parse_bytes(PRIME_STR[2..].as_bytes(), 16).unwrap(); let unit = BigUint::one(); - let felt_max_value = Felt::max_value().to_biguint(); + let felt_max_value = Felt252::max_value().to_biguint(); assert_eq!(prime - unit, felt_max_value) } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - // Tests that the minimum value a Felt can take is equal to zero. + // Tests that the minimum value a Felt252 can take is equal to zero. fn lower_bound() { let zero = BigUint::zero(); - let felt_min_value = Felt::min_value().to_biguint(); + let felt_min_value = Felt252::min_value().to_biguint(); assert_eq!(zero, felt_min_value) } #[test] fn zero_value() { let zero = BigUint::zero(); - let felt_zero = Felt::zero().to_biguint(); + let felt_zero = Felt252::zero().to_biguint(); assert_eq!(zero, felt_zero) } #[test] fn is_zero() { - let felt_zero = Felt::zero(); - let felt_non_zero = Felt::new(3); + let felt_zero = Felt252::zero(); + let felt_non_zero = Felt252::new(3); assert!(felt_zero.is_zero()); assert!(!felt_non_zero.is_zero()) } @@ -1425,21 +1425,21 @@ mod test { #[test] fn one_value() { let one = BigUint::one(); - let felt_one = Felt::one().to_biguint(); + let felt_one = Felt252::one().to_biguint(); assert_eq!(one, felt_one) } #[test] fn is_one() { - let felt_one = Felt::one(); - let felt_non_one = Felt::new(8); + let felt_one = Felt252::one(); + let felt_non_one = Felt252::new(8); assert!(felt_one.is_one()); assert!(!felt_non_one.is_one()) } #[test] fn signum_of_zero_is_zero() { - let zero = Felt::zero(); + let zero = Felt252::zero(); assert_eq!(&zero.signum(), &zero) } } diff --git a/src/cairo_run.rs b/src/cairo_run.rs index 57c61026ad..77d2cbe40d 100644 --- a/src/cairo_run.rs +++ b/src/cairo_run.rs @@ -10,7 +10,7 @@ use crate::{ }; use bincode::enc::write::Writer; -use felt::Felt; +use felt::Felt252; #[cfg(feature = "std")] use thiserror::Error; @@ -104,7 +104,7 @@ pub fn write_encoded_trace( /// * address -> 8-byte encoded /// * value -> 32-byte encoded pub fn write_encoded_memory( - relocated_memory: &[Option], + relocated_memory: &[Option], dest: &mut impl Writer, ) -> Result<(), EncodeTraceError> { for (i, memory_cell) in relocated_memory.iter().enumerate() { @@ -134,7 +134,7 @@ mod tests { utils::test_utils::*, }; use bincode::enc::write::SliceWriter; - use felt::Felt; + use felt::Felt252; #[cfg(target_arch = "wasm32")] use wasm_bindgen_test::*; @@ -176,7 +176,7 @@ mod tests { assert!(cairo_runner.relocate(&mut vm).is_ok()); // `main` returns without doing nothing, but `not_main` sets `[ap]` to `1` // Memory location was found empirically and simply hardcoded - assert_eq!(cairo_runner.relocated_memory[2], Some(Felt::new(123))); + assert_eq!(cairo_runner.relocated_memory[2], Some(Felt252::new(123))); } #[test] diff --git a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs index 62a6528e85..046287ce82 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs @@ -13,11 +13,11 @@ use crate::{ types::relocatable::{MaybeRelocatable, Relocatable}, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_traits::ToPrimitive; fn get_fixed_size_u32_array( - h_range: &Vec>, + h_range: &Vec>, ) -> Result<[u32; T], HintError> { let mut u32_vec = Vec::::with_capacity(h_range.len()); for num in h_range { @@ -31,12 +31,12 @@ fn get_fixed_size_u32_array( fn get_maybe_relocatable_array_from_u32(array: &Vec) -> Vec { let mut new_array = Vec::::with_capacity(array.len()); for element in array { - new_array.push(MaybeRelocatable::from(Felt::new(*element))); + new_array.push(MaybeRelocatable::from(Felt252::new(*element))); } new_array } -fn get_maybe_relocatable_array_from_felt(array: &[Felt]) -> Vec { +fn get_maybe_relocatable_array_from_felt(array: &[Felt252]) -> Vec { array.iter().map(MaybeRelocatable::from).collect() } /*Helper function for the Cairo blake2s() implementation. @@ -139,9 +139,9 @@ pub fn blake2s_add_uint256( const MASK: u32 = u32::MAX; const B: u32 = 32; //Convert MASK to felt - let mask = Felt::new(MASK); + let mask = Felt252::new(MASK); //Build first batch of data - let mut inner_data = Vec::::new(); + let mut inner_data = Vec::::new(); for i in 0..4 { inner_data.push((&low >> (B * i)) & &mask); } @@ -149,7 +149,7 @@ pub fn blake2s_add_uint256( let data = get_maybe_relocatable_array_from_felt(&inner_data); vm.load_data(data_ptr, &data).map_err(HintError::Memory)?; //Build second batch of data - let mut inner_data = Vec::::new(); + let mut inner_data = Vec::::new(); for i in 0..4 { inner_data.push((&high >> (B * i)) & &mask); } @@ -182,9 +182,9 @@ pub fn blake2s_add_uint256_bigend( const MASK: u32 = u32::MAX; const B: u32 = 32; //Convert MASK to felt - let mask = Felt::new(MASK); + let mask = Felt252::new(MASK); //Build first batch of data - let mut inner_data = Vec::::new(); + let mut inner_data = Vec::::new(); for i in 0..4 { inner_data.push((&high >> (B * (3 - i))) & &mask); } @@ -192,7 +192,7 @@ pub fn blake2s_add_uint256_bigend( let data = get_maybe_relocatable_array_from_felt(&inner_data); vm.load_data(data_ptr, &data).map_err(HintError::Memory)?; //Build second batch of data - let mut inner_data = Vec::::new(); + let mut inner_data = Vec::::new(); for i in 0..4 { inner_data.push((&low >> (B * (3 - i))) & &mask); } @@ -409,7 +409,7 @@ mod tests { ) )) if x == MaybeRelocatable::from((2, 0)) && y == MaybeRelocatable::from((2, 0)) && - z == MaybeRelocatable::from(Felt::new(1795745351)) + z == MaybeRelocatable::from(Felt252::new(1795745351)) ); } diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index 6f94342a24..f24925d87b 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -61,7 +61,7 @@ use crate::{ types::exec_scope::ExecutionScopes, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; @@ -90,7 +90,7 @@ pub struct HintFunc( &mut ExecutionScopes, &HashMap, &ApTracking, - &HashMap, + &HashMap, ) -> Result<(), HintError> + Sync, >, @@ -120,7 +120,7 @@ impl HintProcessor for BuiltinHintProcessor { vm: &mut VirtualMachine, exec_scopes: &mut ExecutionScopes, hint_data: &Box, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let hint_data = hint_data .downcast_ref::() @@ -579,7 +579,7 @@ mod tests { // initialize fp vm.run_context.fp = 2; // initialize vm scope with variable `n` - let mut exec_scopes = scope![("n", Felt::one())]; + let mut exec_scopes = scope![("n", Felt252::one())]; // initialize ids.continue_copying // we create a memory gap so that there is None in (1, 0), the actual addr of continue_copying vm.segments = segments![((1, 2), 5)]; @@ -616,7 +616,7 @@ mod tests { // initialize fp vm.run_context.fp = 2; // initialize with variable `n` - let mut exec_scopes = scope![("n", Felt::one())]; + let mut exec_scopes = scope![("n", Felt252::one())]; // initialize ids.continue_copying // a value is written in the address so the hint cant insert value there vm.segments = segments![((1, 1), 5)]; @@ -631,8 +631,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 1)) && - y == MaybeRelocatable::from(Felt::new(5)) && - z == MaybeRelocatable::from(Felt::zero()) + y == MaybeRelocatable::from(Felt252::new(5)) && + z == MaybeRelocatable::from(Felt252::zero()) ); } @@ -643,7 +643,7 @@ mod tests { let mut vm = vm!(); // Create new vm scope with dummy variable let mut exec_scopes = ExecutionScopes::new(); - let a_value: Box = Box::new(Felt::one()); + let a_value: Box = Box::new(Felt252::one()); exec_scopes.enter_scope(HashMap::from([(String::from("a"), a_value)])); // Initialize memory segments add_segments!(vm, 1); @@ -703,7 +703,7 @@ mod tests { ((1, 5), 0) ]; let ids_data = ids_data!["length", "data", "high", "low"]; - let mut exec_scopes = scope![("__keccak_max_size", Felt::new(500))]; + let mut exec_scopes = scope![("__keccak_max_size", Felt252::new(500))]; assert!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes).is_ok()); } @@ -725,10 +725,10 @@ mod tests { ((1, 2), (2, 0)) ]; let ids_data = ids_data!["length", "data", "high", "low"]; - let mut exec_scopes = scope![("__keccak_max_size", Felt::new(2))]; + let mut exec_scopes = scope![("__keccak_max_size", Felt252::new(2))]; assert_matches!( run_hint!(vm, ids_data, hint_code, &mut exec_scopes), - Err(HintError::KeccakMaxSize(x, y)) if x == Felt::new(5) && y == Felt::new(2) + Err(HintError::KeccakMaxSize(x, y)) if x == Felt252::new(5) && y == Felt252::new(2) ); } @@ -773,10 +773,10 @@ mod tests { ((1, 2), (2, 0)) ]; let ids_data = ids_data!["length", "data", "high", "low"]; - let mut exec_scopes = scope![("__keccak_max_size", Felt::new(10))]; + let mut exec_scopes = scope![("__keccak_max_size", Felt252::new(10))]; assert_matches!( run_hint!(vm, ids_data, hint_code, &mut exec_scopes), - Err(HintError::InvalidWordSize(x)) if x == Felt::new(-1) + Err(HintError::InvalidWordSize(x)) if x == Felt252::new(-1) ); } @@ -850,7 +850,7 @@ mod tests { exec_scopes: &mut ExecutionScopes, _ids_data: &HashMap, _ap_tracking: &ApTracking, - _constants: &HashMap, + _constants: &HashMap, ) -> Result<(), HintError> { exec_scopes.enter_scope(HashMap::new()); Ok(()) diff --git a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs index b9cd8c0142..083f35f6b2 100644 --- a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs +++ b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs @@ -17,7 +17,7 @@ use crate::{ vm_core::VirtualMachine, }, }; -use felt::Felt; +use felt::Felt252; use num_traits::{ToPrimitive, Zero}; // Constants in package "starkware.cairo.common.cairo_keccak.keccak". @@ -49,8 +49,8 @@ pub fn keccak_write_args( let low = low.as_ref(); let high = high.as_ref(); - let low_args = [low & Felt::new(u64::MAX), low >> 64]; - let high_args = [high & Felt::new(u64::MAX), high >> 64]; + let low_args = [low & Felt252::new(u64::MAX), low >> 64]; + let high_args = [high & Felt252::new(u64::MAX), high >> 64]; let low_args: Vec<_> = low_args.into_iter().map(MaybeRelocatable::from).collect(); vm.write_arg(inputs_ptr, &low_args) @@ -75,7 +75,7 @@ pub fn compare_bytes_in_word_nondet( vm: &mut VirtualMachine, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let n_bytes = get_integer_from_var_name("n_bytes", vm, ids_data, ap_tracking)?; let n_bytes = n_bytes.as_ref(); @@ -84,11 +84,11 @@ pub fn compare_bytes_in_word_nondet( // One option is to try to convert n_bytes into usize, with failure to do so simply // making value be 0 (if it can't convert then it's either negative, which can't be in Cairo memory // or too big, which also means n_bytes > BYTES_IN_WORD). The other option is to exctract - // Felt::new(BYTES_INTO_WORD) into a lazy_static! + // Felt252::new(BYTES_INTO_WORD) into a lazy_static! let bytes_in_word = constants .get(BYTES_IN_WORD) .ok_or(HintError::MissingConstant(BYTES_IN_WORD))?; - let value = Felt::new((n_bytes < bytes_in_word) as usize); + let value = Felt252::new((n_bytes < bytes_in_word) as usize); insert_value_into_ap(vm, value) } @@ -104,7 +104,7 @@ pub fn compare_keccak_full_rate_in_bytes_nondet( vm: &mut VirtualMachine, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let n_bytes = get_integer_from_var_name("n_bytes", vm, ids_data, ap_tracking)?; let n_bytes = n_bytes.as_ref(); @@ -112,7 +112,7 @@ pub fn compare_keccak_full_rate_in_bytes_nondet( let keccak_full_rate_in_bytes = constants .get(KECCAK_FULL_RATE_IN_BYTES) .ok_or(HintError::MissingConstant(KECCAK_FULL_RATE_IN_BYTES))?; - let value = Felt::new((n_bytes >= keccak_full_rate_in_bytes) as usize); + let value = Felt252::new((n_bytes >= keccak_full_rate_in_bytes) as usize); insert_value_into_ap(vm, value) } @@ -132,14 +132,14 @@ pub fn block_permutation( vm: &mut VirtualMachine, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let keccak_state_size_felts = constants .get(KECCAK_STATE_SIZE_FELTS) .ok_or(HintError::MissingConstant(KECCAK_STATE_SIZE_FELTS))?; - if keccak_state_size_felts >= &Felt::new(100_i32) { - return Err(HintError::InvalidKeccakStateSizeFelts( + if keccak_state_size_felts >= &Felt252::new(100_i32) { + return Err(HintError::InvalidKeccakStateSizeFelt252s( keccak_state_size_felts.clone(), )); } @@ -184,7 +184,7 @@ pub fn cairo_keccak_finalize( vm: &mut VirtualMachine, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let keccak_state_size_felts = constants .get(KECCAK_STATE_SIZE_FELTS) @@ -193,13 +193,13 @@ pub fn cairo_keccak_finalize( .get(BLOCK_SIZE) .ok_or(HintError::MissingConstant(BLOCK_SIZE))?; - if keccak_state_size_felts >= &Felt::new(100_i32) { - return Err(HintError::InvalidKeccakStateSizeFelts( + if keccak_state_size_felts >= &Felt252::new(100_i32) { + return Err(HintError::InvalidKeccakStateSizeFelt252s( keccak_state_size_felts.clone(), )); } - if block_size >= &Felt::new(10_i32) { + if block_size >= &Felt252::new(10_i32) { return Err(HintError::InvalidBlockSize(block_size.clone())); } @@ -211,7 +211,7 @@ pub fn cairo_keccak_finalize( .map_err(|_| VirtualMachineError::SliceToArrayError)?; keccak::f1600(&mut inp); - let mut padding = vec![Felt::zero().into(); keccak_state_size_felts]; + let mut padding = vec![Felt252::zero().into(); keccak_state_size_felts]; padding.extend(u64_array_to_mayberelocatable_vec(&inp)); let base_padding = padding.clone(); @@ -239,7 +239,7 @@ pub(crate) fn maybe_reloc_vec_to_u64_array( Some(Cow::Owned(MaybeRelocatable::Int(ref num))) | Some(Cow::Borrowed(MaybeRelocatable::Int(ref num))) => num .to_u64() - .ok_or_else(|| MathError::FeltToU64Conversion(num.clone()).into()), + .ok_or_else(|| MathError::Felt252ToU64Conversion(num.clone()).into()), _ => Err(VirtualMachineError::ExpectedIntAtRange( n.as_ref().map(|x| x.as_ref().to_owned()), )), @@ -250,7 +250,7 @@ pub(crate) fn maybe_reloc_vec_to_u64_array( } pub fn u64_array_to_mayberelocatable_vec(array: &[u64]) -> Vec { - array.iter().map(|n| Felt::new(*n).into()).collect() + array.iter().map(|n| Felt252::new(*n).into()).collect() } #[cfg(test)] @@ -328,7 +328,7 @@ mod tests { ids_data, hint_code, exec_scopes_ref!(), - &[(KECCAK_FULL_RATE_IN_BYTES, Felt::new(136))] + &[(KECCAK_FULL_RATE_IN_BYTES, Felt252::new(136))] .into_iter() .map(|(k, v)| (k.to_string(), v)) .collect() @@ -357,7 +357,7 @@ mod tests { ids_data, hint_code, exec_scopes_ref!(), - &[(KECCAK_FULL_RATE_IN_BYTES, Felt::new(136))] + &[(KECCAK_FULL_RATE_IN_BYTES, Felt252::new(136))] .into_iter() .map(|(k, v)| (k.to_string(), v)) .collect() @@ -385,7 +385,7 @@ mod tests { ids_data, hint_code, exec_scopes_ref!(), - &[(KECCAK_FULL_RATE_IN_BYTES, Felt::new(136))] + &[(KECCAK_FULL_RATE_IN_BYTES, Felt252::new(136))] .into_iter() .map(|(k, v)| (k.to_string(), v)) .collect() diff --git a/src/hint_processor/builtin_hint_processor/find_element_hint.rs b/src/hint_processor/builtin_hint_processor/find_element_hint.rs index cd0b013b3a..390bbb7cf0 100644 --- a/src/hint_processor/builtin_hint_processor/find_element_hint.rs +++ b/src/hint_processor/builtin_hint_processor/find_element_hint.rs @@ -13,7 +13,7 @@ use crate::{ types::{errors::math_errors::MathError, exec_scope::ExecutionScopes}, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_traits::{Signed, ToPrimitive}; pub fn find_element( @@ -26,7 +26,7 @@ pub fn find_element( let elm_size_bigint = get_integer_from_var_name("elm_size", vm, ids_data, ap_tracking)?; let n_elms = get_integer_from_var_name("n_elms", vm, ids_data, ap_tracking)?; let array_start = get_ptr_from_var_name("array_ptr", vm, ids_data, ap_tracking)?; - let find_element_index = exec_scopes.get::("find_element_index").ok(); + let find_element_index = exec_scopes.get::("find_element_index").ok(); let elm_size = elm_size_bigint .to_usize() .ok_or_else(|| HintError::ValueOutOfRange(elm_size_bigint.as_ref().clone()))?; @@ -55,7 +55,7 @@ pub fn find_element( return Err(HintError::ValueOutOfRange(n_elms.into_owned())); } - if let Ok(find_element_max_size) = exec_scopes.get_ref::("find_element_max_size") { + if let Ok(find_element_max_size) = exec_scopes.get_ref::("find_element_max_size") { if n_elms.as_ref() > find_element_max_size { return Err(HintError::FindElemMaxSize( find_element_max_size.clone(), @@ -65,7 +65,7 @@ pub fn find_element( } let n_elms_iter: i32 = n_elms .to_i32() - .ok_or_else(|| MathError::FeltToI32Conversion(n_elms.into_owned()))?; + .ok_or_else(|| MathError::Felt252ToI32Conversion(n_elms.into_owned()))?; for i in 0..n_elms_iter { let iter_key = vm @@ -75,7 +75,7 @@ pub fn find_element( if iter_key.as_ref() == key.as_ref() { return insert_value_from_var_name( "index", - Felt::new(i), + Felt252::new(i), vm, ids_data, ap_tracking, @@ -93,7 +93,7 @@ pub fn search_sorted_lower( ids_data: &HashMap, ap_tracking: &ApTracking, ) -> Result<(), HintError> { - let find_element_max_size = exec_scopes.get::("find_element_max_size"); + let find_element_max_size = exec_scopes.get::("find_element_max_size"); let n_elms = get_integer_from_var_name("n_elms", vm, ids_data, ap_tracking)?; let rel_array_ptr = get_relocatable_from_var_name("array_ptr", vm, ids_data, ap_tracking)?; let elm_size = get_integer_from_var_name("elm_size", vm, ids_data, ap_tracking)?; @@ -123,7 +123,7 @@ pub fn search_sorted_lower( for i in 0..n_elms_usize { let value = vm.get_integer(array_iter)?; if value.as_ref() >= key.as_ref() { - return insert_value_from_var_name("index", Felt::new(i), vm, ids_data, ap_tracking); + return insert_value_from_var_name("index", Felt252::new(i), vm, ids_data, ap_tracking); } array_iter.offset += elm_size_usize; } @@ -178,13 +178,13 @@ mod tests { let default_values = vec![ ("array_ptr", MaybeRelocatable::from((2, 0))), - ("elm_size", MaybeRelocatable::from(Felt::new(2_i32))), - ("n_elms", MaybeRelocatable::from(Felt::new(2_i32))), - ("key", MaybeRelocatable::from(Felt::new(3_i32))), - ("arr[0].a", MaybeRelocatable::from(Felt::one())), - ("arr[0].b", MaybeRelocatable::from(Felt::new(2_i32))), - ("arr[1].a", MaybeRelocatable::from(Felt::new(3_i32))), - ("arr[1].b", MaybeRelocatable::from(Felt::new(4_i32))), + ("elm_size", MaybeRelocatable::from(Felt252::new(2_i32))), + ("n_elms", MaybeRelocatable::from(Felt252::new(2_i32))), + ("key", MaybeRelocatable::from(Felt252::new(3_i32))), + ("arr[0].a", MaybeRelocatable::from(Felt252::one())), + ("arr[0].b", MaybeRelocatable::from(Felt252::new(2_i32))), + ("arr[1].a", MaybeRelocatable::from(Felt252::new(3_i32))), + ("arr[1].b", MaybeRelocatable::from(Felt252::new(4_i32))), ]; /* array_ptr = (1,0) -> [Struct{1, 2}, Struct{3, 4}] @@ -232,7 +232,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_found_by_oracle() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); - let mut exec_scopes = scope![("find_element_index", Felt::one())]; + let mut exec_scopes = scope![("find_element_index", Felt252::one())]; assert_matches!( run_hint!(vm, ids_data, hint_code::FIND_ELEMENT, &mut exec_scopes), Ok(()) @@ -245,11 +245,11 @@ mod tests { fn element_not_found_search() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "key".to_string(), - MaybeRelocatable::from(Felt::new(7)), + MaybeRelocatable::from(Felt252::new(7)), )])); assert_matches!( run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), - Err(HintError::NoValueForKeyFindElement(x)) if x == Felt::new(7) + Err(HintError::NoValueForKeyFindElement(x)) if x == Felt252::new(7) ); } @@ -257,7 +257,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn element_not_found_oracle() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); - let mut exec_scopes = scope![("find_element_index", Felt::new(2))]; + let mut exec_scopes = scope![("find_element_index", Felt252::new(2))]; assert_matches!( run_hint!(vm, ids_data, hint_code::FIND_ELEMENT, &mut exec_scopes), Err(HintError::KeyNotFound) @@ -296,11 +296,11 @@ mod tests { fn find_elm_zero_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), - MaybeRelocatable::Int(Felt::zero()), + MaybeRelocatable::Int(Felt252::zero()), )])); assert_matches!( run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), - Err(HintError::ValueOutOfRange(x)) if x == Felt::zero() + Err(HintError::ValueOutOfRange(x)) if x == Felt252::zero() ); } @@ -309,11 +309,11 @@ mod tests { fn find_elm_negative_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), - MaybeRelocatable::Int(Felt::new(-1)), + MaybeRelocatable::Int(Felt252::new(-1)), )])); assert_matches!( run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), - Err(HintError::ValueOutOfRange(x)) if x == Felt::new(-1) + Err(HintError::ValueOutOfRange(x)) if x == Felt252::new(-1) ); } @@ -335,11 +335,11 @@ mod tests { fn find_elm_negative_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), - MaybeRelocatable::Int(Felt::new(-1)), + MaybeRelocatable::Int(Felt252::new(-1)), )])); assert_matches!( run_hint!(vm, ids_data, hint_code::FIND_ELEMENT), - Err(HintError::ValueOutOfRange(x)) if x == Felt::new(-1) + Err(HintError::ValueOutOfRange(x)) if x == Felt252::new(-1) ); } @@ -354,10 +354,10 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn find_elm_n_elms_gt_max_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); - let mut exec_scopes = scope![("find_element_max_size", Felt::one())]; + let mut exec_scopes = scope![("find_element_max_size", Felt252::one())]; assert_matches!( run_hint!(vm, ids_data, hint_code::FIND_ELEMENT, &mut exec_scopes), - Err(HintError::FindElemMaxSize(x, y)) if x == Felt::one() && y == Felt::new(2) + Err(HintError::FindElemMaxSize(x, y)) if x == Felt252::one() && y == Felt252::new(2) ); } @@ -390,7 +390,7 @@ mod tests { fn search_sorted_lower_no_matches() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "key".to_string(), - MaybeRelocatable::Int(Felt::new(7)), + MaybeRelocatable::Int(Felt252::new(7)), )])); assert_matches!( run_hint!(vm, ids_data, hint_code::SEARCH_SORTED_LOWER), @@ -418,7 +418,7 @@ mod tests { fn search_sorted_lower_zero_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), - MaybeRelocatable::Int(Felt::zero()), + MaybeRelocatable::Int(Felt252::zero()), )])); assert_matches!( run_hint!(vm, ids_data, hint_code::SEARCH_SORTED_LOWER), @@ -431,11 +431,11 @@ mod tests { fn search_sorted_lower_negative_elm_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "elm_size".to_string(), - MaybeRelocatable::Int(Felt::new(-1)), + MaybeRelocatable::Int(Felt252::new(-1)), )])); assert_matches!( run_hint!(vm, ids_data, hint_code::SEARCH_SORTED_LOWER), - Err(HintError::ValueOutOfRange(x)) if x == Felt::new(-1) + Err(HintError::ValueOutOfRange(x)) if x == Felt252::new(-1) ); } @@ -458,11 +458,11 @@ mod tests { fn search_sorted_lower_negative_n_elms() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::from([( "n_elms".to_string(), - MaybeRelocatable::Int(Felt::new(-1)), + MaybeRelocatable::Int(Felt252::new(-1)), )])); assert_matches!( run_hint!(vm, ids_data, hint_code::SEARCH_SORTED_LOWER), - Err(HintError::ValueOutOfRange(x)) if x == Felt::new(-1) + Err(HintError::ValueOutOfRange(x)) if x == Felt252::new(-1) ); } @@ -480,7 +480,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn search_sorted_lower_n_elms_gt_max_size() { let (mut vm, ids_data) = init_vm_ids_data(HashMap::new()); - let mut exec_scopes = scope![("find_element_max_size", Felt::one())]; + let mut exec_scopes = scope![("find_element_max_size", Felt252::one())]; assert_matches!( run_hint!( vm, @@ -488,7 +488,7 @@ mod tests { hint_code::SEARCH_SORTED_LOWER, &mut exec_scopes ), - Err(HintError::FindElemMaxSize(x, y)) if x == Felt::one() && y == Felt::new(2) + Err(HintError::FindElemMaxSize(x, y)) if x == Felt252::one() && y == Felt252::new(2) ); } } diff --git a/src/hint_processor/builtin_hint_processor/hint_utils.rs b/src/hint_processor/builtin_hint_processor/hint_utils.rs index 796ebe2911..66c891ff5e 100644 --- a/src/hint_processor/builtin_hint_processor/hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/hint_utils.rs @@ -1,6 +1,6 @@ use crate::stdlib::{borrow::Cow, collections::HashMap, prelude::*}; -use felt::Felt; +use felt::Felt252; use crate::hint_processor::hint_processor_definition::HintReference; use crate::hint_processor::hint_processor_utils::{ @@ -86,7 +86,7 @@ pub fn get_integer_from_var_name<'a>( vm: &'a VirtualMachine, ids_data: &'a HashMap, ap_tracking: &ApTracking, -) -> Result, HintError> { +) -> Result, HintError> { let reference = get_reference_from_var_name(var_name, ids_data)?; match get_integer_from_reference(vm, reference, ap_tracking) { // Map internal errors into more descriptive variants @@ -248,7 +248,7 @@ mod tests { assert_matches!( get_integer_from_var_name("value", &vm, &ids_data, &ApTracking::new()), - Ok(Cow::Borrowed(x)) if x == &Felt::new(1) + Ok(Cow::Borrowed(x)) if x == &Felt252::new(1) ); } diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index af2c259fdf..673ff2d7be 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -11,7 +11,7 @@ use crate::{ types::{exec_scope::ExecutionScopes, relocatable::Relocatable}, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_traits::{One, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; @@ -46,7 +46,7 @@ pub fn unsafe_keccak( ) -> Result<(), HintError> { let length = get_integer_from_var_name("length", vm, ids_data, ap_tracking)?; - if let Ok(keccak_max_size) = exec_scopes.get::("__keccak_max_size") { + if let Ok(keccak_max_size) = exec_scopes.get::("__keccak_max_size") { if length.as_ref() > &keccak_max_size { return Err(HintError::KeccakMaxSize( length.into_owned(), @@ -76,7 +76,7 @@ pub fn unsafe_keccak( let word = vm.get_integer(word_addr)?; let n_bytes = cmp::min(16, u64_length - byte_i); - if word.is_negative() || word.as_ref() >= &Felt::one().shl(8 * (n_bytes as u32)) { + if word.is_negative() || word.as_ref() >= &Felt252::one().shl(8 * (n_bytes as u32)) { return Err(HintError::InvalidWordSize(word.into_owned())); } @@ -94,8 +94,8 @@ pub fn unsafe_keccak( let hashed = hasher.finalize(); - let high = Felt::from_bytes_be(&hashed[..16]); - let low = Felt::from_bytes_be(&hashed[16..32]); + let high = Felt252::from_bytes_be(&hashed[..16]); + let low = Felt252::from_bytes_be(&hashed[16..32]); vm.insert_value(high_addr, &high)?; vm.insert_value(low_addr, &low)?; @@ -167,8 +167,8 @@ pub fn unsafe_keccak_finalize( let high_addr = get_relocatable_from_var_name("high", vm, ids_data, ap_tracking)?; let low_addr = get_relocatable_from_var_name("low", vm, ids_data, ap_tracking)?; - let high = Felt::from_bytes_be(&hashed[..16]); - let low = Felt::from_bytes_be(&hashed[16..32]); + let high = Felt252::from_bytes_be(&hashed[..16]); + let low = Felt252::from_bytes_be(&hashed[16..32]); vm.insert_value(high_addr, &high)?; vm.insert_value(low_addr, &low)?; diff --git a/src/hint_processor/builtin_hint_processor/math_utils.rs b/src/hint_processor/builtin_hint_processor/math_utils.rs index 8a12232418..b1968ae966 100644 --- a/src/hint_processor/builtin_hint_processor/math_utils.rs +++ b/src/hint_processor/builtin_hint_processor/math_utils.rs @@ -23,7 +23,7 @@ use crate::{ vm_core::VirtualMachine, }, }; -use felt::Felt; +use felt::Felt252; use num_bigint::BigUint; use num_integer::Integer; use num_traits::One; @@ -41,8 +41,8 @@ pub fn is_nn( let range_check_builtin = vm.get_range_check_builtin()?; //Main logic (assert a is not negative and within the expected range) let value = match &range_check_builtin._bound { - Some(bound) if a.as_ref() >= bound => Felt::one(), - _ => Felt::zero(), + Some(bound) if a.as_ref() >= bound => Felt252::one(), + _ => Felt252::zero(), }; insert_value_into_ap(vm, value) } @@ -59,9 +59,9 @@ pub fn is_nn_out_of_range( //Main logic (assert a is not negative and within the expected range) //let value = if (-a - 1usize).mod_floor(vm.get_prime()) < range_check_builtin._bound { let value = match &range_check_builtin._bound { - Some(bound) if Felt::zero() - (a + 1) < *bound => Felt::zero(), - None => Felt::zero(), - _ => Felt::one(), + Some(bound) if Felt252::zero() - (a + 1) < *bound => Felt252::zero(), + None => Felt252::zero(), + _ => Felt252::one(), }; insert_value_into_ap(vm, value) } @@ -79,7 +79,7 @@ pub fn assert_le_felt( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { const PRIME_OVER_3_HIGH: &str = "starkware.cairo.common.math.assert_le_felt.PRIME_OVER_3_HIGH"; const PRIME_OVER_2_HIGH: &str = "starkware.cairo.common.math.assert_le_felt.PRIME_OVER_2_HIGH"; @@ -99,26 +99,26 @@ pub fn assert_le_felt( let range_check_ptr = get_ptr_from_var_name("range_check_ptr", vm, ids_data, ap_tracking)?; if a > b { - return Err(HintError::NonLeFelt(a.clone(), b.clone())); + return Err(HintError::NonLeFelt252(a.clone(), b.clone())); } let arc1 = b - a; - let arc2 = Felt::zero() - Felt::one() - b; + let arc2 = Felt252::zero() - Felt252::one() - b; let mut lengths_and_indices = vec![(a, 0_i32), (&arc1, 1_i32), (&arc2, 2_i32)]; lengths_and_indices.sort(); - if lengths_and_indices[0].0 > &div_prime_by_bound(Felt::new(3_i32))? - || lengths_and_indices[1].0 > &div_prime_by_bound(Felt::new(2_i32))? + if lengths_and_indices[0].0 > &div_prime_by_bound(Felt252::new(3_i32))? + || lengths_and_indices[1].0 > &div_prime_by_bound(Felt252::new(2_i32))? { return Err(HintError::ArcTooBig( lengths_and_indices[0].0.clone(), - div_prime_by_bound(Felt::new(3_i32))?, + div_prime_by_bound(Felt252::new(3_i32))?, lengths_and_indices[1].0.clone(), - div_prime_by_bound(Felt::new(3_i32))?, + div_prime_by_bound(Felt252::new(3_i32))?, )); } let excluded = lengths_and_indices[2].1; - exec_scopes.assign_or_update_variable("excluded", any_box!(Felt::new(excluded))); + exec_scopes.assign_or_update_variable("excluded", any_box!(Felt252::new(excluded))); let (q_0, r_0) = (lengths_and_indices[0].0).div_mod_floor(prime_over_3_high); let (q_1, r_1) = (lengths_and_indices[1].0).div_mod_floor(prime_over_2_high); @@ -131,9 +131,9 @@ pub fn assert_le_felt( } pub fn assert_le_felt_excluded_2(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { - let excluded: Felt = exec_scopes.get("excluded")?; + let excluded: Felt252 = exec_scopes.get("excluded")?; - if excluded != Felt::new(2_i32) { + if excluded != Felt252::new(2_i32) { Err(HintError::ExcludedNot2(excluded)) } else { Ok(()) @@ -144,12 +144,12 @@ pub fn assert_le_felt_excluded_1( vm: &mut VirtualMachine, exec_scopes: &mut ExecutionScopes, ) -> Result<(), HintError> { - let excluded: Felt = exec_scopes.get("excluded")?; + let excluded: Felt252 = exec_scopes.get("excluded")?; - if excluded != Felt::one() { - insert_value_into_ap(vm, &Felt::one()) + if excluded != Felt252::one() { + insert_value_into_ap(vm, &Felt252::one()) } else { - insert_value_into_ap(vm, &Felt::zero()) + insert_value_into_ap(vm, &Felt252::zero()) } } @@ -157,12 +157,12 @@ pub fn assert_le_felt_excluded_0( vm: &mut VirtualMachine, exec_scopes: &mut ExecutionScopes, ) -> Result<(), HintError> { - let excluded: Felt = exec_scopes.get("excluded")?; + let excluded: Felt252 = exec_scopes.get("excluded")?; if !excluded.is_zero() { - insert_value_into_ap(vm, Felt::one()) + insert_value_into_ap(vm, Felt252::one()) } else { - insert_value_into_ap(vm, Felt::zero()) + insert_value_into_ap(vm, Felt252::zero()) } } @@ -176,9 +176,9 @@ pub fn is_le_felt( let a_mod = get_integer_from_var_name("a", vm, ids_data, ap_tracking)?; let b_mod = get_integer_from_var_name("b", vm, ids_data, ap_tracking)?; let value = if a_mod > b_mod { - Felt::one() + Felt252::one() } else { - Felt::zero() + Felt252::zero() }; insert_value_into_ap(vm, value) } @@ -322,9 +322,9 @@ pub fn is_positive( }; let result = if value.is_positive() { - Felt::one() + Felt252::one() } else { - Felt::zero() + Felt252::zero() }; insert_value_from_var_name("is_positive", result, vm, ids_data, ap_tracking) } @@ -349,8 +349,8 @@ pub fn split_felt( //assert_integer(ids.value) (done by match) // ids.low = ids.value & ((1 << 128) - 1) // ids.high = ids.value >> 128 - let low: Felt = value & ((Felt::one().shl(128_u32)) - Felt::one()); - let high: Felt = value.shr(128_u32); + let low: Felt252 = value & ((Felt252::one().shl(128_u32)) - Felt252::one()); + let high: Felt252 = value.shr(128_u32); insert_value_from_var_name("high", high, vm, ids_data, ap_tracking)?; insert_value_from_var_name("low", low, vm, ids_data, ap_tracking) } @@ -366,7 +366,7 @@ pub fn sqrt( ap_tracking: &ApTracking, ) -> Result<(), HintError> { let mod_value = get_integer_from_var_name("value", vm, ids_data, ap_tracking)?; - //This is equal to mod_value > Felt::new(2).pow(250) + //This is equal to mod_value > Felt252::new(2).pow(250) if mod_value.as_ref().shr(250_u32).is_positive() { return Err(HintError::ValueOutside250BitRange(mod_value.into_owned())); //This is equal to mod_value > bigint!(2).pow(250) @@ -374,7 +374,7 @@ pub fn sqrt( #[allow(deprecated)] insert_value_from_var_name( "root", - Felt::new(isqrt(&mod_value.to_biguint())?), + Felt252::new(isqrt(&mod_value.to_biguint())?), vm, ids_data, ap_tracking, @@ -410,7 +410,7 @@ pub fn signed_div_rem( None if div.is_zero() => { return Err(HintError::OutOfValidRange( div.into_owned(), - Felt::zero() - Felt::one(), + Felt252::zero() - Felt252::one(), )); } _ => {} @@ -425,12 +425,21 @@ pub fn signed_div_rem( let (q, r) = int_value.div_mod_floor(&int_div); if int_bound.abs() < q.abs() { - return Err(HintError::OutOfValidRange(Felt::new(q), bound.into_owned())); + return Err(HintError::OutOfValidRange( + Felt252::new(q), + bound.into_owned(), + )); } let biased_q = q + int_bound; - insert_value_from_var_name("r", Felt::new(r), vm, ids_data, ap_tracking)?; - insert_value_from_var_name("biased_q", Felt::new(biased_q), vm, ids_data, ap_tracking) + insert_value_from_var_name("r", Felt252::new(r), vm, ids_data, ap_tracking)?; + insert_value_from_var_name( + "biased_q", + Felt252::new(biased_q), + vm, + ids_data, + ap_tracking, + ) } /* @@ -464,7 +473,7 @@ pub fn unsigned_div_rem( None if div.is_zero() => { return Err(HintError::OutOfValidRange( div.into_owned(), - Felt::zero() - Felt::one(), + Felt252::zero() - Felt252::one(), )); } _ => {} @@ -487,8 +496,8 @@ pub fn assert_250_bit( ap_tracking: &ApTracking, ) -> Result<(), HintError> { //Declare constant values - let upper_bound = Felt::one().shl(250u32); - let shift = Felt::one().shl(128u32); + let upper_bound = Felt252::one().shl(250u32); + let shift = Felt252::one().shl(128u32); let value = get_integer_from_var_name("value", vm, ids_data, ap_tracking)?; //Main logic //can be deleted @@ -523,16 +532,16 @@ pub fn assert_lt_felt( // assert (ids.a % PRIME) < (ids.b % PRIME), \ // f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.' if a >= b { - return Err(HintError::AssertLtFelt(a.into_owned(), b.into_owned())); + return Err(HintError::AssertLtFelt252(a.into_owned(), b.into_owned())); }; Ok(()) } -fn div_prime_by_bound(bound: Felt) -> Result { +fn div_prime_by_bound(bound: Felt252) -> Result { let prime: &BigUint = &CAIRO_PRIME; #[allow(deprecated)] let limit = prime / bound.to_biguint(); - Ok(Felt::new(limit)) + Ok(Felt252::new(limit)) } #[cfg(test)] @@ -765,8 +774,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 0)) && - y == MaybeRelocatable::Int(Felt::one()) && - z == MaybeRelocatable::Int(Felt::zero()) + y == MaybeRelocatable::Int(Felt252::one()) && + z == MaybeRelocatable::Int(Felt252::zero()) ); } @@ -815,7 +824,7 @@ mod tests { //Execute the hint assert_matches!( run_hint!(vm, ids_data, hint_code), - Err(HintError::AssertNNValueOutOfRange(x)) if x == Felt::new(-1) + Err(HintError::AssertNNValueOutOfRange(x)) if x == Felt252::new(-1) ); } @@ -904,7 +913,7 @@ mod tests { "starkware.cairo.common.math.assert_le_felt.PRIME_OVER_2_HIGH".to_string(), felt_str!("2AAAAAAAAAAAAB05555555555555556", 16), ); - let mut exec_scopes = scope![("excluded", Felt::one())]; + let mut exec_scopes = scope![("excluded", Felt252::one())]; //Initialize fp vm.run_context.fp = 3; //Insert ids into memory @@ -914,7 +923,7 @@ mod tests { //Execute the hint assert_matches!( run_hint!(vm, ids_data, hint_code, &mut exec_scopes, &constants), - Err(HintError::NonLeFelt(x, y)) if x == Felt::new(2) && y == Felt::one() + Err(HintError::NonLeFelt252(x, y)) if x == Felt252::new(2) && y == Felt252::one() ); } @@ -1025,8 +1034,8 @@ mod tests { Err(HintError::AssertNotEqualFail( x, y - )) if x == MaybeRelocatable::from(Felt::one()) && - y == MaybeRelocatable::from(Felt::one()) + )) if x == MaybeRelocatable::from(Felt252::one()) && + y == MaybeRelocatable::from(Felt252::one()) ); } @@ -1141,7 +1150,7 @@ mod tests { x, y ) - )) if x == MaybeRelocatable::from((1, 0)) && y == MaybeRelocatable::from(Felt::one()) + )) if x == MaybeRelocatable::from((1, 0)) && y == MaybeRelocatable::from(Felt252::one()) ); } @@ -1178,7 +1187,7 @@ mod tests { Err(HintError::AssertNotZero( x, y - )) if x == Felt::zero() && y == *felt::PRIME_STR.to_string() + )) if x == Felt252::zero() && y == *felt::PRIME_STR.to_string() ); } @@ -1285,7 +1294,7 @@ mod tests { //Execute the hint assert_matches!( run_hint!(vm, ids_data, hint_code), - Err(HintError::SplitIntLimbOutOfRange(x)) if x == Felt::new(100) + Err(HintError::SplitIntLimbOutOfRange(x)) if x == Felt252::new(100) ); } @@ -1374,8 +1383,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 1)) && - y == MaybeRelocatable::from(Felt::new(4)) && - z == MaybeRelocatable::from(Felt::one()) + y == MaybeRelocatable::from(Felt252::new(4)) && + z == MaybeRelocatable::from(Felt252::one()) ); } @@ -1437,8 +1446,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 1)) && - y == MaybeRelocatable::from(Felt::new(7)) && - z == MaybeRelocatable::from(Felt::new(9)) + y == MaybeRelocatable::from(Felt252::new(7)) && + z == MaybeRelocatable::from(Felt252::new(9)) ); } @@ -1475,7 +1484,7 @@ mod tests { Err(HintError::OutOfValidRange( x, y - )) if x == Felt::new(-5) && y == felt_str!("340282366920938463463374607431768211456") + )) if x == Felt252::new(-5) && y == felt_str!("340282366920938463463374607431768211456") ) } @@ -1519,8 +1528,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 0)) && - y == MaybeRelocatable::Int(Felt::new(5)) && - z == MaybeRelocatable::Int(Felt::new(2)) + y == MaybeRelocatable::Int(Felt252::new(5)) && + z == MaybeRelocatable::Int(Felt252::new(2)) ); } @@ -1591,7 +1600,7 @@ mod tests { Err(HintError::OutOfValidRange( x, y - )) if x == Felt::new(-5) && y == felt_str!("340282366920938463463374607431768211456") + )) if x == Felt252::new(-5) && y == felt_str!("340282366920938463463374607431768211456") ) } @@ -1635,8 +1644,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 1)) && - y == MaybeRelocatable::Int(Felt::new(10)) && - z == MaybeRelocatable::Int(Felt::new(31)) + y == MaybeRelocatable::Int(Felt252::new(10)) && + z == MaybeRelocatable::Int(Felt252::new(31)) ); } @@ -1697,7 +1706,7 @@ mod tests { //Execute the hint assert_matches!( run_hint!(vm, ids_data, hint_code), - Err(HintError::ValueOutside250BitRange(x)) if x == Felt::one().shl(251_u32) + Err(HintError::ValueOutside250BitRange(x)) if x == Felt252::one().shl(251_u32) ); } @@ -1782,7 +1791,7 @@ mod tests { z ) )) if x == MaybeRelocatable::from((2, 0)) && - y == MaybeRelocatable::from(Felt::new(99)) && + y == MaybeRelocatable::from(Felt252::new(99)) && z == MaybeRelocatable::from(felt_str!("335438970432432812899076431678123043273")) ); } @@ -1817,8 +1826,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((2, 1)) && - y == MaybeRelocatable::from(Felt::new(99)) && - z == MaybeRelocatable::from(Felt::new(0)) + y == MaybeRelocatable::from(Felt252::new(99)) && + z == MaybeRelocatable::from(Felt252::new(0)) ); } @@ -1874,7 +1883,7 @@ mod tests { //Execute the hint assert_matches!( run_hint!(vm, ids_data, hint_code), - Err(HintError::AssertLtFelt(x, y)) if x == Felt::new(3) && y == Felt::new(2) + Err(HintError::AssertLtFelt252(x, y)) if x == Felt252::new(3) && y == Felt252::new(2) ); } diff --git a/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs b/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs index 4ac912179b..6cfa942c9e 100644 --- a/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memcpy_hint_utils.rs @@ -11,7 +11,7 @@ use crate::{ types::exec_scope::ExecutionScopes, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_traits::{One, Zero}; //Implements hint: memory[ap] = segments.add() @@ -58,7 +58,7 @@ pub fn memcpy_continue_copying( ap_tracking: &ApTracking, ) -> Result<(), HintError> { // get `n` variable from vm scope - let n = exec_scopes.get_ref::("n")?; + let n = exec_scopes.get_ref::("n")?; // this variable will hold the value of `n - 1` let new_n = n - 1; // if it is positive, insert 1 in the address of `continue_copying` @@ -66,7 +66,13 @@ pub fn memcpy_continue_copying( if new_n.is_zero() { insert_value_from_var_name("continue_copying", &new_n, vm, ids_data, ap_tracking)?; } else { - insert_value_from_var_name("continue_copying", Felt::one(), vm, ids_data, ap_tracking)?; + insert_value_from_var_name( + "continue_copying", + Felt252::one(), + vm, + ids_data, + ap_tracking, + )?; } exec_scopes.insert_value("n", new_n); Ok(()) @@ -108,7 +114,7 @@ mod tests { get_integer_from_var_name(var_name, &vm, &ids_data, &ApTracking::default()) .unwrap() .as_ref(), - &Felt::new(10) + &Felt252::new(10) ); } diff --git a/src/hint_processor/builtin_hint_processor/memset_utils.rs b/src/hint_processor/builtin_hint_processor/memset_utils.rs index f915c544f2..0065c38223 100644 --- a/src/hint_processor/builtin_hint_processor/memset_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memset_utils.rs @@ -11,7 +11,7 @@ use crate::{ types::exec_scope::ExecutionScopes, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_traits::Signed; // Implements hint: @@ -41,12 +41,12 @@ pub fn memset_continue_loop( ap_tracking: &ApTracking, ) -> Result<(), HintError> { // get `n` variable from vm scope - let n = exec_scopes.get_ref::("n")?; + let n = exec_scopes.get_ref::("n")?; // this variable will hold the value of `n - 1` let new_n = n - 1; // if `new_n` is positive, insert 1 in the address of `continue_loop` // else, insert 0 - let should_continue = Felt::new(new_n.is_positive() as i32); + let should_continue = Felt252::new(new_n.is_positive() as i32); insert_value_from_var_name("continue_loop", should_continue, vm, ids_data, ap_tracking)?; // Reassign `n` with `n - 1` // we do it at the end of the function so that the borrow checker doesn't complain @@ -116,7 +116,7 @@ mod tests { // initialize fp vm.run_context.fp = 1; // initialize vm scope with variable `n` = 1 - let mut exec_scopes = scope![("n", Felt::one())]; + let mut exec_scopes = scope![("n", Felt252::one())]; // initialize ids.continue_loop // we create a memory gap so that there is None in (1, 0), the actual addr of continue_loop vm.segments = segments![((1, 1), 5)]; @@ -134,7 +134,7 @@ mod tests { // initialize fp vm.run_context.fp = 1; // initialize vm scope with variable `n` = 5 - let mut exec_scopes = scope![("n", Felt::new(5))]; + let mut exec_scopes = scope![("n", Felt252::new(5))]; // initialize ids.continue_loop // we create a memory gap so that there is None in (0, 0), the actual addr of continue_loop vm.segments = segments![((1, 2), 5)]; @@ -155,7 +155,7 @@ mod tests { // we don't initialize `n` now: /* vm.exec_scopes - .assign_or_update_variable("n", Felt::one())); */ + .assign_or_update_variable("n", Felt252::one())); */ // initialize ids.continue_loop // we create a memory gap so that there is None in (0, 1), the actual addr of continue_loop @@ -175,7 +175,7 @@ mod tests { // initialize fp vm.run_context.fp = 1; // initialize with variable `n` - let mut exec_scopes = scope![("n", Felt::one())]; + let mut exec_scopes = scope![("n", Felt252::one())]; // initialize ids.continue_loop // a value is written in the address so the hint cant insert value there vm.segments = segments![((1, 0), 5)]; @@ -189,8 +189,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 0)) && - y == MaybeRelocatable::from(Felt::new(5)) && - z == MaybeRelocatable::from(Felt::zero()) + y == MaybeRelocatable::from(Felt252::new(5)) && + z == MaybeRelocatable::from(Felt252::zero()) ); } } diff --git a/src/hint_processor/builtin_hint_processor/pow_utils.rs b/src/hint_processor/builtin_hint_processor/pow_utils.rs index 7986ac277b..5cad6a95ee 100644 --- a/src/hint_processor/builtin_hint_processor/pow_utils.rs +++ b/src/hint_processor/builtin_hint_processor/pow_utils.rs @@ -10,7 +10,7 @@ use crate::{ serde::deserialize_program::ApTracking, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_integer::Integer; /* @@ -30,7 +30,13 @@ pub fn pow( HintError::IdentifierHasNoMember("prev_locs".to_string(), "exp".to_string()) })?; let locs_bit = prev_locs_exp.is_odd(); - insert_value_from_var_name("locs", Felt::new(locs_bit as u8), vm, ids_data, ap_tracking)?; + insert_value_from_var_name( + "locs", + Felt252::new(locs_bit as u8), + vm, + ids_data, + ap_tracking, + )?; Ok(()) } @@ -146,8 +152,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 11)) && - y == MaybeRelocatable::from(Felt::new(3)) && - z == MaybeRelocatable::from(Felt::one()) + y == MaybeRelocatable::from(Felt252::new(3)) && + z == MaybeRelocatable::from(Felt252::one()) ); } } diff --git a/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs b/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs index 4c8d59772e..c97dbf63f9 100644 --- a/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/bigint_utils.rs @@ -14,13 +14,13 @@ use crate::{ }, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; #[derive(Debug, PartialEq)] pub(crate) struct BigInt3<'a> { - pub d0: Cow<'a, Felt>, - pub d1: Cow<'a, Felt>, - pub d2: Cow<'a, Felt>, + pub d0: Cow<'a, Felt252>, + pub d1: Cow<'a, Felt252>, + pub d2: Cow<'a, Felt252>, } impl BigInt3<'_> { @@ -66,7 +66,7 @@ pub fn nondet_bigint3( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let res_reloc = get_relocatable_from_var_name("res", vm, ids_data, ap_tracking)?; let value = exec_scopes @@ -75,7 +75,7 @@ pub fn nondet_bigint3( .ok_or(HintError::BigIntToBigUintFail)?; let arg: Vec = split(&value, constants)? .into_iter() - .map(|n| MaybeRelocatable::from(Felt::new(n))) + .map(|n| MaybeRelocatable::from(Felt252::new(n))) .collect(); vm.write_arg(res_reloc, &arg).map_err(HintError::Memory)?; Ok(()) @@ -87,7 +87,7 @@ pub fn bigint_to_uint256( vm: &mut VirtualMachine, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let x_struct = get_relocatable_from_var_name("x", vm, ids_data, ap_tracking)?; let d0 = vm.get_integer(x_struct)?; @@ -97,7 +97,7 @@ pub fn bigint_to_uint256( let base_86 = constants .get(BASE_86) .ok_or(HintError::MissingConstant(BASE_86))?; - let low = (d0 + &(d1 * base_86)) & &Felt::new(u128::MAX); + let low = (d0 + &(d1 * base_86)) & &Felt252::new(u128::MAX); insert_value_from_var_name("low", low, vm, ids_data, ap_tracking) } @@ -147,7 +147,7 @@ mod tests { ids_data, hint_code, &mut exec_scopes, - &[(BASE_86, Felt::one().shl(86_u32))] + &[(BASE_86, Felt252::one().shl(86_u32))] .into_iter() .map(|(k, v)| (k.to_string(), v)) .collect() @@ -201,9 +201,9 @@ mod tests { let mut vm = vm!(); vm.segments = segments![((0, 0), 1), ((0, 1), 2), ((0, 2), 3)]; let x = BigInt3::from_base_addr((0, 0).into(), "x", &vm).unwrap(); - assert_eq!(x.d0.as_ref(), &Felt::one()); - assert_eq!(x.d1.as_ref(), &Felt::from(2)); - assert_eq!(x.d2.as_ref(), &Felt::from(3)); + assert_eq!(x.d0.as_ref(), &Felt252::one()); + assert_eq!(x.d1.as_ref(), &Felt252::from(2)); + assert_eq!(x.d2.as_ref(), &Felt252::from(3)); } #[test] @@ -223,9 +223,9 @@ mod tests { vm.segments = segments![((1, 0), 1), ((1, 1), 2), ((1, 2), 3)]; let ids_data = ids_data!["x"]; let x = BigInt3::from_var_name("x", &vm, &ids_data, &ApTracking::default()).unwrap(); - assert_eq!(x.d0.as_ref(), &Felt::one()); - assert_eq!(x.d1.as_ref(), &Felt::from(2)); - assert_eq!(x.d2.as_ref(), &Felt::from(3)); + assert_eq!(x.d0.as_ref(), &Felt252::one()); + assert_eq!(x.d1.as_ref(), &Felt252::from(2)); + assert_eq!(x.d2.as_ref(), &Felt252::from(3)); } #[test] diff --git a/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs b/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs index 5e2cabf9e5..c7711bfce0 100644 --- a/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/ec_utils.rs @@ -18,7 +18,7 @@ use crate::{ types::exec_scope::ExecutionScopes, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_bigint::BigInt; use num_integer::Integer; use num_traits::{One, Zero}; @@ -61,7 +61,7 @@ pub fn ec_negate( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = num_bigint::BigInt::one().shl(256u32) @@ -97,7 +97,7 @@ pub fn compute_doubling_slope( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = num_bigint::BigInt::one().shl(256usize) @@ -134,7 +134,7 @@ pub fn compute_slope( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = BigInt::one().shl(256usize) @@ -175,7 +175,7 @@ pub fn ec_double_assign_new_x( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = BigInt::one().shl(256usize) @@ -210,7 +210,7 @@ Implements hint: */ pub fn ec_double_assign_new_y( exec_scopes: &mut ExecutionScopes, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = BigInt::one().shl(256usize) @@ -251,7 +251,7 @@ pub fn fast_ec_add_assign_new_x( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = BigInt::one().shl(256usize) @@ -289,7 +289,7 @@ Implements hint: */ pub fn fast_ec_add_assign_new_y( exec_scopes: &mut ExecutionScopes, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = BigInt::one().shl(256usize) @@ -324,7 +324,7 @@ pub fn ec_mul_inner( //(ids.scalar % PRIME) % 2 let scalar = get_integer_from_var_name("scalar", vm, ids_data, ap_tracking)? .as_ref() - .bitand(&Felt::one()); + .bitand(&Felt252::one()); insert_value_into_ap(vm, scalar) } @@ -377,13 +377,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -429,13 +429,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -501,13 +501,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -570,13 +570,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -654,13 +654,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -732,13 +732,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -804,13 +804,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -879,12 +879,12 @@ mod tests { let ids_data = ids_data!["e"]; let ap_tracking = ApTracking::default(); let e = EcPoint::from_var_name("e", &vm, &ids_data, &ap_tracking).unwrap(); - assert_eq!(e.x.d0.as_ref(), &Felt::one()); - assert_eq!(e.x.d1.as_ref(), &Felt::from(2)); - assert_eq!(e.x.d2.as_ref(), &Felt::from(3)); - assert_eq!(e.y.d0.as_ref(), &Felt::from(4)); - assert_eq!(e.y.d1.as_ref(), &Felt::from(5)); - assert_eq!(e.y.d2.as_ref(), &Felt::from(6)); + assert_eq!(e.x.d0.as_ref(), &Felt252::one()); + assert_eq!(e.x.d1.as_ref(), &Felt252::from(2)); + assert_eq!(e.x.d2.as_ref(), &Felt252::from(3)); + assert_eq!(e.y.d0.as_ref(), &Felt252::from(4)); + assert_eq!(e.y.d1.as_ref(), &Felt252::from(5)); + assert_eq!(e.y.d2.as_ref(), &Felt252::from(6)); } #[test] diff --git a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs index fea37db3ea..aad73265b0 100644 --- a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs @@ -13,7 +13,7 @@ use crate::{ types::exec_scope::ExecutionScopes, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_bigint::BigInt; use num_integer::Integer; use num_traits::{One, Zero}; @@ -34,7 +34,7 @@ pub fn verify_zero( vm: &mut VirtualMachine, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = BigInt::one().shl(256_u32) @@ -49,7 +49,7 @@ pub fn verify_zero( return Err(HintError::SecpVerifyZero(val)); } - insert_value_from_var_name("q", Felt::new(q), vm, ids_data, ap_tracking) + insert_value_from_var_name("q", Felt252::new(q), vm, ids_data, ap_tracking) } /* @@ -65,7 +65,7 @@ pub fn reduce( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = num_bigint::BigInt::one().shl(256_u32) @@ -92,7 +92,7 @@ pub fn is_zero_pack( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = BigInt::one().shl(256_u32) @@ -123,9 +123,9 @@ pub fn is_zero_nondet( let x = exec_scopes.get::("x")?; let value = if x.is_zero() { - Felt::one() + Felt252::one() } else { - Felt::zero() + Felt252::zero() }; insert_value_into_ap(vm, value) } @@ -141,7 +141,7 @@ Implements hint: */ pub fn is_zero_assign_scope_variables( exec_scopes: &mut ExecutionScopes, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let secp_p = BigInt::one().shl(256_u32) @@ -206,13 +206,13 @@ mod tests { exec_scopes_ref!(), &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -245,13 +245,13 @@ mod tests { exec_scopes_ref!(), &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -285,13 +285,13 @@ mod tests { exec_scopes_ref!(), &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -304,8 +304,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 9)) && - y == MaybeRelocatable::from(Felt::new(55_i32)) && - z == MaybeRelocatable::from(Felt::zero()) + y == MaybeRelocatable::from(Felt252::new(55_i32)) && + z == MaybeRelocatable::from(Felt252::zero()) ); } @@ -338,13 +338,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -384,13 +384,13 @@ mod tests { exec_scopes_ref!(), &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -430,13 +430,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -480,13 +480,13 @@ mod tests { exec_scopes_ref!(), &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -597,8 +597,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from(vm.run_context.get_ap()) && - y == MaybeRelocatable::from(Felt::new(55i32)) && - z == MaybeRelocatable::from(Felt::new(1i32)) + y == MaybeRelocatable::from(Felt252::new(55i32)) && + z == MaybeRelocatable::from(Felt252::new(1i32)) ); } @@ -625,13 +625,13 @@ mod tests { &mut exec_scopes, &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -672,13 +672,13 @@ mod tests { exec_scopes_ref!(), &[( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() )] .into_iter() .map(|(k, v)| (k.to_string(), v)) diff --git a/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs b/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs index 60b0232daf..e2613998bf 100644 --- a/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/secp_utils.rs @@ -1,7 +1,7 @@ use crate::stdlib::{collections::HashMap, ops::Shl, prelude::*}; use crate::vm::errors::hint_errors::HintError; -use felt::Felt; +use felt::Felt252; use num_traits::Zero; @@ -25,7 +25,7 @@ where BASE = 2**86. */ pub fn split( integer: &num_bigint::BigUint, - constants: &HashMap, + constants: &HashMap, ) -> Result<[num_bigint::BigUint; 3], HintError> { #[allow(deprecated)] let base_86_max = constants @@ -48,7 +48,7 @@ pub fn split( } /* -Takes an UnreducedFelt3 struct which represents a triple of limbs (d0, d1, d2) of field +Takes an UnreducedFelt2523 struct which represents a triple of limbs (d0, d1, d2) of field elements and reconstructs the corresponding 256-bit integer (see split()). Note that the limbs do not have to be in the range [0, BASE). */ @@ -79,7 +79,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn secp_split() { let mut constants = HashMap::new(); - constants.insert(BASE_86.to_string(), Felt::one() << 86_usize); + constants.insert(BASE_86.to_string(), Felt252::one() << 86_usize); let array_1 = split(&BigUint::zero(), &constants); #[allow(deprecated)] @@ -150,9 +150,9 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn secp_pack() { let pack_1 = pack(BigInt3 { - d0: Cow::Borrowed(&Felt::new(10_i32)), - d1: Cow::Borrowed(&Felt::new(10_i32)), - d2: Cow::Borrowed(&Felt::new(10_i32)), + d0: Cow::Borrowed(&Felt252::new(10_i32)), + d1: Cow::Borrowed(&Felt252::new(10_i32)), + d2: Cow::Borrowed(&Felt252::new(10_i32)), }); assert_eq!( pack_1, diff --git a/src/hint_processor/builtin_hint_processor/secp/signature.rs b/src/hint_processor/builtin_hint_processor/secp/signature.rs index 8364e94c6a..7a84441921 100644 --- a/src/hint_processor/builtin_hint_processor/secp/signature.rs +++ b/src/hint_processor/builtin_hint_processor/secp/signature.rs @@ -18,7 +18,7 @@ use crate::{ vm::errors::hint_errors::HintError, vm::vm_core::VirtualMachine, }; -use felt::Felt; +use felt::Felt252; use num_bigint::BigInt; use num_integer::Integer; use num_traits::One; @@ -38,7 +38,7 @@ pub fn div_mod_n_packed_divmod( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let a = pack(BigInt3::from_var_name("a", vm, ids_data, ap_tracking)?); let b = pack(BigInt3::from_var_name("b", vm, ids_data, ap_tracking)?); @@ -77,7 +77,7 @@ pub fn div_mod_n_packed_divmod( // value = k = safe_div(res * b - a, N) pub fn div_mod_n_safe_div( exec_scopes: &mut ExecutionScopes, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { let a = exec_scopes.get_ref::("a")?; let b = exec_scopes.get_ref::("b")?; @@ -116,7 +116,7 @@ pub fn get_point_from_x( exec_scopes: &mut ExecutionScopes, ids_data: &HashMap, ap_tracking: &ApTracking, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError> { #[allow(deprecated)] let beta = constants @@ -191,10 +191,10 @@ mod tests { let ids_data = non_continuous_ids_data![("a", -3), ("b", 0)]; let mut exec_scopes = ExecutionScopes::new(); let constants = [ - (BASE_86, Felt::one().shl(86_u32)), - (N0, Felt::new(10428087374290690730508609u128)), - (N1, Felt::new(77371252455330678278691517u128)), - (N2, Felt::new(19342813113834066795298815u128)), + (BASE_86, Felt252::one().shl(86_u32)), + (N0, Felt252::new(10428087374290690730508609u128)), + (N1, Felt252::new(77371252455330678278691517u128)), + (N2, Felt252::new(19342813113834066795298815u128)), ] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -218,10 +218,10 @@ mod tests { div_mod_n_safe_div( &mut exec_scopes, &[ - (BASE_86, Felt::one().shl(86_u32)), - (N0, Felt::new(10428087374290690730508609u128)), - (N1, Felt::new(77371252455330678278691517u128)), - (N2, Felt::new(19342813113834066795298815u128)), + (BASE_86, Felt252::one().shl(86_u32)), + (N0, Felt252::new(10428087374290690730508609u128)), + (N1, Felt252::new(77371252455330678278691517u128)), + (N2, Felt252::new(19342813113834066795298815u128)), ] .into_iter() .map(|(k, v)| (k.to_string(), v)) @@ -256,16 +256,16 @@ mod tests { hint_code, exec_scopes_ref!(), &[ - (BETA, Felt::new(7)), + (BETA, Felt252::new(7)), ( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() ), ] .into_iter() @@ -298,16 +298,16 @@ mod tests { hint_code, &mut exec_scopes, &[ - (BETA, Felt::new(7)), + (BETA, Felt252::new(7)), ( SECP_REM, - Felt::one().shl(32_u32) - + Felt::one().shl(9_u32) - + Felt::one().shl(8_u32) - + Felt::one().shl(7_u32) - + Felt::one().shl(6_u32) - + Felt::one().shl(4_u32) - + Felt::one() + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() ), ] .into_iter() diff --git a/src/hint_processor/builtin_hint_processor/set.rs b/src/hint_processor/builtin_hint_processor/set.rs index 79ae9984ad..0358a0d463 100644 --- a/src/hint_processor/builtin_hint_processor/set.rs +++ b/src/hint_processor/builtin_hint_processor/set.rs @@ -11,7 +11,7 @@ use crate::{ types::{errors::math_errors::MathError, relocatable::MaybeRelocatable}, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_traits::{One, ToPrimitive, Zero}; pub fn set_add( @@ -23,7 +23,7 @@ pub fn set_add( let elm_size = get_integer_from_var_name("elm_size", vm, ids_data, ap_tracking).and_then(|x| { x.to_usize() - .ok_or_else(|| MathError::FeltToUsizeConversion(x.into_owned()).into()) + .ok_or_else(|| MathError::Felt252ToUsizeConversion(x.into_owned()).into()) })?; let elm_ptr = get_ptr_from_var_name("elm_ptr", vm, ids_data, ap_tracking)?; let set_end_ptr = get_ptr_from_var_name("set_end_ptr", vm, ids_data, ap_tracking)?; @@ -50,21 +50,21 @@ pub fn set_add( if set_iter == elm { insert_value_from_var_name( "index", - Felt::new(i / elm_size), + Felt252::new(i / elm_size), vm, ids_data, ap_tracking, )?; return insert_value_from_var_name( "is_elm_in_set", - Felt::one(), + Felt252::one(), vm, ids_data, ap_tracking, ); } } - insert_value_from_var_name("is_elm_in_set", Felt::zero(), vm, ids_data, ap_tracking) + insert_value_from_var_name("is_elm_in_set", Felt252::zero(), vm, ids_data, ap_tracking) } #[cfg(test)] @@ -143,7 +143,7 @@ mod tests { .get(&MaybeRelocatable::from((1, 0))) .unwrap() .as_ref(), - &MaybeRelocatable::Int(Felt::zero()) + &MaybeRelocatable::Int(Felt252::zero()) ) } @@ -161,7 +161,7 @@ mod tests { let (mut vm, ids_data) = init_vm_ids_data(None, Some(-2), None, None); assert_matches!( run_hint!(vm, ids_data, HINT_CODE), - Err(HintError::Math(MathError::FeltToUsizeConversion(_))) + Err(HintError::Math(MathError::Felt252ToUsizeConversion(_))) ); } diff --git a/src/hint_processor/builtin_hint_processor/sha256_utils.rs b/src/hint_processor/builtin_hint_processor/sha256_utils.rs index 096ba782d2..e6ccffc8c6 100644 --- a/src/hint_processor/builtin_hint_processor/sha256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/sha256_utils.rs @@ -12,7 +12,7 @@ use crate::{ vm::errors::{hint_errors::HintError, vm_errors::VirtualMachineError}, vm::vm_core::VirtualMachine, }; -use felt::Felt; +use felt::Felt252; use generic_array::GenericArray; use num_traits::{One, Zero}; use sha2::compress256; @@ -36,10 +36,10 @@ pub fn sha256_input( insert_value_from_var_name( "full_word", - if n_bytes >= &Felt::new(4_i32) { - Felt::one() + if n_bytes >= &Felt252::new(4_i32) { + Felt252::one() } else { - Felt::zero() + Felt252::zero() }, vm, ids_data, @@ -69,7 +69,7 @@ pub fn sha256_main( let mut output: Vec = Vec::with_capacity(SHA256_STATE_SIZE_FELTS); for new_state in iv { - output.push(Felt::new(new_state).into()); + output.push(Felt252::new(new_state).into()); } let output_base = get_ptr_from_var_name("output", vm, ids_data, ap_tracking)?; @@ -88,7 +88,7 @@ pub fn sha256_finalize( let mut iv = IV; - let iv_static: Vec = iv.iter().map(|n| Felt::new(*n).into()).collect(); + let iv_static: Vec = iv.iter().map(|n| Felt252::new(*n).into()).collect(); let new_message = GenericArray::clone_from_slice(&message); compress256(&mut iv, &[new_message]); @@ -96,13 +96,13 @@ pub fn sha256_finalize( let mut output: Vec = Vec::with_capacity(SHA256_STATE_SIZE_FELTS); for new_state in iv { - output.push(Felt::new(new_state).into()); + output.push(Felt252::new(new_state).into()); } let sha256_ptr_end = get_ptr_from_var_name("sha256_ptr_end", vm, ids_data, ap_tracking)?; let mut padding: Vec = Vec::new(); - let zero_vector_message: Vec = vec![Felt::zero().into(); 16]; + let zero_vector_message: Vec = vec![Felt252::zero().into(); 16]; for _ in 0..BLOCK_SIZE - 1 { padding.extend_from_slice(zero_vector_message.as_slice()); diff --git a/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs b/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs index c4bb1a0ebf..8aa830422a 100644 --- a/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs +++ b/src/hint_processor/builtin_hint_processor/squash_dict_utils.rs @@ -18,19 +18,19 @@ use crate::{ vm_core::VirtualMachine, }, }; -use felt::Felt; +use felt::Felt252; use num_integer::Integer; use num_traits::{One, ToPrimitive, Zero}; fn get_access_indices( exec_scopes: &mut ExecutionScopes, -) -> Result<&HashMap>, HintError> { - let mut access_indices: Option<&HashMap>> = None; +) -> Result<&HashMap>, HintError> { + let mut access_indices: Option<&HashMap>> = None; if let Some(variable) = exec_scopes .get_local_variables_mut()? .get_mut("access_indices") { - if let Some(py_access_indices) = variable.downcast_mut::>>() { + if let Some(py_access_indices) = variable.downcast_mut::>>() { access_indices = Some(py_access_indices); } } @@ -49,7 +49,7 @@ pub fn squash_dict_inner_first_iteration( ap_tracking: &ApTracking, ) -> Result<(), HintError> { //Check that access_indices and key are in scope - let key = exec_scopes.get::("key")?; + let key = exec_scopes.get::("key")?; let range_check_ptr = get_ptr_from_var_name("range_check_ptr", vm, ids_data, ap_tracking)?; let access_indices = get_access_indices(exec_scopes)?; //Get current_indices from access_indices @@ -79,12 +79,12 @@ pub fn squash_dict_inner_skip_loop( ap_tracking: &ApTracking, ) -> Result<(), HintError> { //Check that current_access_indices is in scope - let current_access_indices = exec_scopes.get_list_ref::("current_access_indices")?; + let current_access_indices = exec_scopes.get_list_ref::("current_access_indices")?; //Main Logic let should_skip_loop = if current_access_indices.is_empty() { - Felt::one() + Felt252::one() } else { - Felt::zero() + Felt252::zero() }; insert_value_from_var_name( "should_skip_loop", @@ -107,13 +107,14 @@ pub fn squash_dict_inner_check_access_index( ap_tracking: &ApTracking, ) -> Result<(), HintError> { //Check that current_access_indices and current_access_index are in scope - let current_access_index = exec_scopes.get::("current_access_index")?; - let current_access_indices = exec_scopes.get_mut_list_ref::("current_access_indices")?; + let current_access_index = exec_scopes.get::("current_access_index")?; + let current_access_indices = + exec_scopes.get_mut_list_ref::("current_access_indices")?; //Main Logic let new_access_index = current_access_indices .pop() .ok_or(HintError::EmptyCurrentAccessIndices)?; - let index_delta_minus1 = new_access_index.clone() - current_access_index - Felt::one(); + let index_delta_minus1 = new_access_index.clone() - current_access_index - Felt252::one(); //loop_temps.delta_minus1 = loop_temps + 0 as it is the first field of the struct //Insert loop_temps.delta_minus1 into memory insert_value_from_var_name("loop_temps", index_delta_minus1, vm, ids_data, ap_tracking)?; @@ -133,12 +134,12 @@ pub fn squash_dict_inner_continue_loop( //Get addr for ids variables let loop_temps_addr = get_relocatable_from_var_name("loop_temps", vm, ids_data, ap_tracking)?; //Check that current_access_indices is in scope - let current_access_indices = exec_scopes.get_list_ref::("current_access_indices")?; + let current_access_indices = exec_scopes.get_list_ref::("current_access_indices")?; //Main Logic let should_continue = if current_access_indices.is_empty() { - Felt::zero() + Felt252::zero() } else { - Felt::one() + Felt252::one() }; //loop_temps.delta_minus1 = loop_temps + 3 as it is the fourth field of the struct //Insert loop_temps.delta_minus1 into memory @@ -150,7 +151,7 @@ pub fn squash_dict_inner_continue_loop( // Implements Hint: assert len(current_access_indices) == 0 pub fn squash_dict_inner_len_assert(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { //Check that current_access_indices is in scope - let current_access_indices = exec_scopes.get_list_ref::("current_access_indices")?; + let current_access_indices = exec_scopes.get_list_ref::("current_access_indices")?; if !current_access_indices.is_empty() { return Err(HintError::CurrentAccessIndicesNotEmpty); } @@ -164,7 +165,7 @@ pub fn squash_dict_inner_used_accesses_assert( ids_data: &HashMap, ap_tracking: &ApTracking, ) -> Result<(), HintError> { - let key = exec_scopes.get::("key")?; + let key = exec_scopes.get::("key")?; let n_used_accesses = get_integer_from_var_name("n_used_accesses", vm, ids_data, ap_tracking)?; let access_indices = get_access_indices(exec_scopes)?; //Main Logic @@ -172,7 +173,7 @@ pub fn squash_dict_inner_used_accesses_assert( .get(&key) .ok_or_else(|| HintError::NoKeyInAccessIndices(key.clone()))?; - if n_used_accesses.as_ref() != &Felt::new(access_indices_at_key.len()) { + if n_used_accesses.as_ref() != &Felt252::new(access_indices_at_key.len()) { return Err(HintError::NumUsedAccessesAssertFail( n_used_accesses.into_owned(), access_indices_at_key.len(), @@ -187,7 +188,7 @@ pub fn squash_dict_inner_assert_len_keys( exec_scopes: &mut ExecutionScopes, ) -> Result<(), HintError> { //Check that current_access_indices is in scope - let keys = exec_scopes.get_list_ref::("keys")?; + let keys = exec_scopes.get_list_ref::("keys")?; if !keys.is_empty() { return Err(HintError::KeysNotEmpty); }; @@ -204,7 +205,7 @@ pub fn squash_dict_inner_next_key( ap_tracking: &ApTracking, ) -> Result<(), HintError> { //Check that current_access_indices is in scope - let keys = exec_scopes.get_mut_list_ref::("keys")?; + let keys = exec_scopes.get_mut_list_ref::("keys")?; let next_key = keys.pop().ok_or(HintError::EmptyKeys)?; //Insert next_key into ids.next_keys insert_value_from_var_name("next_key", next_key.clone(), vm, ids_data, ap_tracking)?; @@ -248,10 +249,10 @@ pub fn squash_dict( let range_check_builtin = vm.get_range_check_builtin()?; let range_check_bound = range_check_builtin._bound.clone(); //Main Logic - if ptr_diff.mod_floor(&Felt::new(DICT_ACCESS_SIZE)) != Felt::zero() { + if ptr_diff.mod_floor(&Felt252::new(DICT_ACCESS_SIZE)) != Felt252::zero() { return Err(HintError::PtrDiffNotDivisibleByDictAccessSize); } - let squash_dict_max_size = exec_scopes.get::("__squash_dict_max_size"); + let squash_dict_max_size = exec_scopes.get::("__squash_dict_max_size"); if let Ok(max_size) = squash_dict_max_size { if n_accesses.as_ref() > &max_size { return Err(HintError::SquashDictMaxSizeExceeded( @@ -264,7 +265,7 @@ pub fn squash_dict( .to_usize() .ok_or_else(|| HintError::NAccessesTooBig(n_accesses.into_owned()))?; //A map from key to the list of indices accessing it. - let mut access_indices = HashMap::>::new(); + let mut access_indices = HashMap::>::new(); for i in 0..n_accesses_usize { let key_addr = (address + DICT_ACCESS_SIZE * i)?; let key = vm @@ -273,17 +274,17 @@ pub fn squash_dict( access_indices .entry(key.into_owned()) .or_default() - .push(Felt::new(i)); + .push(Felt252::new(i)); } //Descending list of keys. - let mut keys: Vec = access_indices.keys().cloned().collect(); + let mut keys: Vec = access_indices.keys().cloned().collect(); keys.sort(); keys.reverse(); //Are the keys used bigger than the range_check bound. let big_keys = if keys[0] >= range_check_bound.unwrap() { - Felt::one() + Felt252::one() } else { - Felt::zero() + Felt252::zero() }; insert_value_from_var_name("big_keys", big_keys, vm, ids_data, ap_tracking)?; let key = keys.pop().ok_or(HintError::EmptyKeys)?; @@ -339,14 +340,18 @@ mod tests { fn squash_dict_inner_first_iteration_valid() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //Prepare scope variables - let mut access_indices = HashMap::>::new(); - let current_accessed_indices = - vec![Felt::new(9), Felt::new(3), Felt::new(10), Felt::new(7)]; - access_indices.insert(Felt::new(5), current_accessed_indices); + let mut access_indices = HashMap::>::new(); + let current_accessed_indices = vec![ + Felt252::new(9), + Felt252::new(3), + Felt252::new(10), + Felt252::new(7), + ]; + access_indices.insert(Felt252::new(5), current_accessed_indices); //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt::new(5))]; + let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt252::new(5))]; //Initialize fp vm.run_context.fp = 1; //Insert ids into memory (range_check_ptr) @@ -362,9 +367,9 @@ mod tests { [ ( "current_access_indices", - vec![Felt::new(10), Felt::new(9), Felt::new(7)] + vec![Felt252::new(10), Felt252::new(9), Felt252::new(7)] ), - ("current_access_index", Felt::new(3)) + ("current_access_index", Felt252::new(3)) ] ); //Check that current_access_index is now at range_check_ptr @@ -376,14 +381,14 @@ mod tests { fn squash_dict_inner_first_iteration_empty_accessed_indices() { let hint_code = SQUASH_DICT_INNER_FIRST_ITERATION; //Prepare scope variables - let mut access_indices = HashMap::>::new(); + let mut access_indices = HashMap::>::new(); //Leave current_accessed_indices empty - let current_accessed_indices = Vec::::new(); - access_indices.insert(Felt::new(5), current_accessed_indices); + let current_accessed_indices = Vec::::new(); + access_indices.insert(Felt252::new(5), current_accessed_indices); //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt::new(5))]; + let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt252::new(5))]; //Initialize fp vm.run_context.fp = 1; //Insert ids into memory (range_check_ptr) @@ -425,7 +430,7 @@ mod tests { let mut vm = vm!(); add_segments!(vm, 2); //Store scope variables - let mut exec_scopes = scope![("current_access_indices", Vec::::new())]; + let mut exec_scopes = scope![("current_access_indices", Vec::::new())]; //Initialize fp vm.run_context.fp = 1; //Create ids_data @@ -444,7 +449,10 @@ mod tests { let mut vm = vm!(); add_segments!(vm, 2); //Store scope variables - let mut exec_scopes = scope![("current_access_indices", vec![Felt::new(4), Felt::new(7)])]; + let mut exec_scopes = scope![( + "current_access_indices", + vec![Felt252::new(4), Felt252::new(7)] + )]; //Initialize fp vm.run_context.fp = 1; //Create ids_data @@ -466,9 +474,14 @@ mod tests { let mut exec_scopes = scope![ ( "current_access_indices", - vec![Felt::new(10), Felt::new(9), Felt::new(7), Felt::new(5)] + vec![ + Felt252::new(10), + Felt252::new(9), + Felt252::new(7), + Felt252::new(5) + ] ), - ("current_access_index", Felt::one()) + ("current_access_index", Felt252::one()) ]; //Initialize fp vm.run_context.fp = 1; @@ -482,10 +495,10 @@ mod tests { [ ( "current_access_indices", - vec![Felt::new(10), Felt::new(9), Felt::new(7)] + vec![Felt252::new(10), Felt252::new(9), Felt252::new(7)] ), - ("new_access_index", Felt::new(5)), - ("current_access_index", Felt::new(5)) + ("new_access_index", Felt252::new(5)), + ("current_access_index", Felt252::new(5)) ] ); //Check the value of loop_temps.index_delta_minus_1 @@ -502,8 +515,8 @@ mod tests { let mut vm = vm!(); //Store scope variables let mut exec_scopes = scope![ - ("current_access_indices", Vec::::new()), - ("current_access_index", Felt::one()) + ("current_access_indices", Vec::::new()), + ("current_access_index", Felt252::one()) ]; //Initialize fp vm.run_context.fp = 1; @@ -526,7 +539,10 @@ mod tests { let mut vm = vm!(); add_segments!(vm, 2); //Store scope variables - let mut exec_scopes = scope![("current_access_indices", vec![Felt::new(4), Felt::new(7)])]; + let mut exec_scopes = scope![( + "current_access_indices", + vec![Felt252::new(4), Felt252::new(7)] + )]; //Initialize fp vm.run_context.fp = 1; //Create ids_data @@ -545,7 +561,7 @@ mod tests { let mut vm = vm!(); add_segments!(vm, 2); //Store scope variables - let mut exec_scopes = scope![("current_access_indices", Vec::::new())]; + let mut exec_scopes = scope![("current_access_indices", Vec::::new())]; //Initialize fp vm.run_context.fp = 1; //Create ids_data @@ -563,7 +579,7 @@ mod tests { //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("current_access_indices", Vec::::new())]; + let mut exec_scopes = scope![("current_access_indices", Vec::::new())]; //Execute the hint //Hint should produce an error if assertion fails assert_matches!( @@ -579,7 +595,7 @@ mod tests { //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("current_access_indices", vec![Felt::new(29)])]; + let mut exec_scopes = scope![("current_access_indices", vec![Felt252::new(29)])]; //Execute the hint //Hint should produce an error if assertion fails assert_matches!( @@ -593,14 +609,18 @@ mod tests { fn squash_dict_inner_uses_accesses_assert_valid() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables - let mut access_indices = HashMap::>::new(); - let current_accessed_indices = - vec![Felt::new(9), Felt::new(3), Felt::new(10), Felt::new(7)]; - access_indices.insert(Felt::new(5), current_accessed_indices); + let mut access_indices = HashMap::>::new(); + let current_accessed_indices = vec![ + Felt252::new(9), + Felt252::new(3), + Felt252::new(10), + Felt252::new(7), + ]; + access_indices.insert(Felt252::new(5), current_accessed_indices); //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt::new(5))]; + let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt252::new(5))]; //Initialize fp vm.run_context.fp = 1; //Insert ids into memory (n_used_accesses) @@ -617,14 +637,18 @@ mod tests { fn squash_dict_inner_uses_accesses_assert_wrong_used_access_number() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables - let mut access_indices = HashMap::>::new(); - let current_accessed_indices = - vec![Felt::new(9), Felt::new(3), Felt::new(10), Felt::new(7)]; - access_indices.insert(Felt::new(5), current_accessed_indices); + let mut access_indices = HashMap::>::new(); + let current_accessed_indices = vec![ + Felt252::new(9), + Felt252::new(3), + Felt252::new(10), + Felt252::new(7), + ]; + access_indices.insert(Felt252::new(5), current_accessed_indices); //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt::new(5))]; + let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt252::new(5))]; //Initialize fp vm.run_context.fp = 1; //Insert ids into memory (n_used_accesses) @@ -638,7 +662,7 @@ mod tests { x, 4, y - )) if x == Felt::new(5) && y == Felt::new(5) + )) if x == Felt252::new(5) && y == Felt252::new(5) ); } @@ -647,14 +671,18 @@ mod tests { fn squash_dict_inner_uses_accesses_assert_used_access_number_relocatable() { let hint_code = SQUASH_DICT_INNER_USED_ACCESSES_ASSERT; //Prepare scope variables - let mut access_indices = HashMap::>::new(); - let current_accessed_indices = - vec![Felt::new(9), Felt::new(3), Felt::new(10), Felt::new(7)]; - access_indices.insert(Felt::new(5), current_accessed_indices); + let mut access_indices = HashMap::>::new(); + let current_accessed_indices = vec![ + Felt252::new(9), + Felt252::new(3), + Felt252::new(10), + Felt252::new(7), + ]; + access_indices.insert(Felt252::new(5), current_accessed_indices); //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt::new(5))]; + let mut exec_scopes = scope![("access_indices", access_indices), ("key", Felt252::new(5))]; //Initialize fp vm.run_context.fp = 1; //Insert ids into memory (n_used_accesses) @@ -675,7 +703,7 @@ mod tests { //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("keys", Vec::::new())]; + let mut exec_scopes = scope![("keys", Vec::::new())]; //Execute the hint assert_matches!( run_hint!(vm, HashMap::new(), hint_code, &mut exec_scopes), @@ -690,7 +718,7 @@ mod tests { //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("keys", vec![Felt::new(3)])]; + let mut exec_scopes = scope![("keys", vec![Felt252::new(3)])]; //Execute the hint assert_matches!( run_hint!(vm, HashMap::new(), hint_code, &mut exec_scopes), @@ -719,7 +747,7 @@ mod tests { let mut vm = vm!(); add_segments!(vm, 2); //Store scope variables - let mut exec_scopes = scope![("keys", vec![Felt::one(), Felt::new(3)])]; + let mut exec_scopes = scope![("keys", vec![Felt252::one(), Felt252::new(3)])]; //Initialize fp vm.run_context.fp = 1; //Create hint_data @@ -731,7 +759,7 @@ mod tests { //Check local variables check_scope!( &exec_scopes, - [("keys", vec![Felt::one()]), ("key", Felt::new(3))] + [("keys", vec![Felt252::one()]), ("key", Felt252::new(3))] ); } @@ -742,7 +770,7 @@ mod tests { //Create vm let mut vm = vm!(); //Store scope variables - let mut exec_scopes = scope![("keys", Vec::::new())]; + let mut exec_scopes = scope![("keys", Vec::::new())]; //Initialize fp vm.run_context.fp = 1; //Create hint_data @@ -787,14 +815,14 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - let access_indices_scope_value: HashMap> = - HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]); + let access_indices_scope_value: HashMap> = + HashMap::from([(Felt252::one(), vec![Felt252::zero(), Felt252::one()])]); check_scope!( &exec_scopes, [ ("access_indices", access_indices_scope_value), - ("keys", Vec::::new()), - ("key", Felt::one()) + ("keys", Vec::::new()), + ("key", Felt252::one()) ] ); //Check ids variables @@ -840,20 +868,20 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - let access_indices_scope_value: HashMap> = HashMap::from([ - (Felt::one(), vec![Felt::zero(), Felt::one()]), - (Felt::new(2), vec![Felt::new(2), Felt::new(3)]), + let access_indices_scope_value: HashMap> = HashMap::from([ + (Felt252::one(), vec![Felt252::zero(), Felt252::one()]), + (Felt252::new(2), vec![Felt252::new(2), Felt252::new(3)]), ]); check_scope!( &exec_scopes, [ ("access_indices", access_indices_scope_value), - ("keys", vec![Felt::new(2)]), - ("key", Felt::one()) + ("keys", vec![Felt252::new(2)]), + ("key", Felt252::one()) ] ); - let keys = exec_scopes.get_list_ref::("keys").unwrap(); - assert_eq!(*keys, vec![Felt::new(2)]); + let keys = exec_scopes.get_list_ref::("keys").unwrap(); + assert_eq!(*keys, vec![Felt252::new(2)]); //Check ids variables check_memory![vm.segments.memory, ((1, 1), 0), ((1, 2), 1)]; } @@ -866,7 +894,7 @@ mod tests { //Create vm let mut vm = vm_with_range_check!(); //Create scope variables - let mut exec_scopes = scope![("__squash_dict_max_size", Felt::new(12))]; + let mut exec_scopes = scope![("__squash_dict_max_size", Felt252::new(12))]; //Initialize fp vm.run_context.fp = 5; //Insert ids into memory @@ -892,14 +920,14 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - let access_indices_scope_value: HashMap> = - HashMap::from([(Felt::one(), vec![Felt::zero(), Felt::one()])]); + let access_indices_scope_value: HashMap> = + HashMap::from([(Felt252::one(), vec![Felt252::zero(), Felt252::one()])]); check_scope!( &exec_scopes, [ ("access_indices", access_indices_scope_value), - ("keys", Vec::::new()), - ("key", Felt::one()) + ("keys", Vec::::new()), + ("key", Felt252::one()) ] ); //Check ids variables @@ -914,7 +942,7 @@ mod tests { //Create vm let mut vm = vm_with_range_check!(); //Create scope variables - let mut exec_scopes = scope![("__squash_dict_max_size", Felt::one())]; + let mut exec_scopes = scope![("__squash_dict_max_size", Felt252::one())]; //Initialize fp vm.run_context.fp = 5; //Insert ids into memory @@ -943,7 +971,7 @@ mod tests { Err(HintError::SquashDictMaxSizeExceeded( x, y - )) if x == Felt::one() && y == Felt::new(2) + )) if x == Felt252::one() && y == Felt252::new(2) ); } @@ -1071,13 +1099,13 @@ mod tests { //Execute the hint assert_matches!(run_hint!(vm, ids_data, hint_code, &mut exec_scopes), Ok(())); //Check scope variables - let access_indices_scope_value: HashMap> = HashMap::from([( + let access_indices_scope_value: HashMap> = HashMap::from([( felt_str!( "3618502761706184546546682988428055018603476541694452277432519575032261771265" ), - vec![Felt::zero(), Felt::one()], + vec![Felt252::zero(), Felt252::one()], )]); - check_scope!(&exec_scopes, [("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"))]); + check_scope!(&exec_scopes, [("access_indices", access_indices_scope_value), ("keys", Vec::::new()), ("key", felt_str!("3618502761706184546546682988428055018603476541694452277432519575032261771265"))]); //Check ids variables check_memory![ vm.segments.memory, diff --git a/src/hint_processor/builtin_hint_processor/uint256_utils.rs b/src/hint_processor/builtin_hint_processor/uint256_utils.rs index 155a497ec9..0eb2b51e48 100644 --- a/src/hint_processor/builtin_hint_processor/uint256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/uint256_utils.rs @@ -13,7 +13,7 @@ use crate::{ serde::deserialize_program::ApTracking, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_integer::div_rem; use num_traits::{One, Signed, Zero}; /* @@ -30,7 +30,7 @@ pub fn uint256_add( ids_data: &HashMap, ap_tracking: &ApTracking, ) -> Result<(), HintError> { - let shift = Felt::new(1_u32) << 128_u32; + let shift = Felt252::new(1_u32) << 128_u32; let a_relocatable = get_relocatable_from_var_name("a", vm, ids_data, ap_tracking)?; let b_relocatable = get_relocatable_from_var_name("b", vm, ids_data, ap_tracking)?; let a_low = vm.get_integer(a_relocatable)?; @@ -49,15 +49,15 @@ pub fn uint256_add( //ids.carry_high = 1 if sum_high >= ids.SHIFT else 0 let carry_low = if a_low + b_low >= shift { - Felt::one() + Felt252::one() } else { - Felt::zero() + Felt252::zero() }; let carry_high = if a_high + b_high + &carry_low >= shift { - Felt::one() + Felt252::one() } else { - Felt::zero() + Felt252::zero() }; insert_value_from_var_name("carry_high", carry_high, vm, ids_data, ap_tracking)?; insert_value_from_var_name("carry_low", carry_low, vm, ids_data, ap_tracking) @@ -77,9 +77,9 @@ pub fn split_64( ) -> Result<(), HintError> { let a = get_integer_from_var_name("a", vm, ids_data, ap_tracking)?; let mut digits = a.iter_u64_digits(); - let low = Felt::new(digits.next().unwrap_or(0u64)); + let low = Felt252::new(digits.next().unwrap_or(0u64)); let high = if digits.len() <= 1 { - Felt::new(digits.next().unwrap_or(0u64)) + Felt252::new(digits.next().unwrap_or(0u64)) } else { a.as_ref().shr(64_u32) }; @@ -127,8 +127,8 @@ pub fn uint256_sqrt( &root ))); } - vm.insert_value(root_addr, Felt::new(root))?; - vm.insert_value((root_addr + 1_i32)?, Felt::zero()) + vm.insert_value(root_addr, Felt252::new(root))?; + vm.insert_value((root_addr + 1_i32)?, Felt252::zero()) .map_err(HintError::Memory) } @@ -145,10 +145,10 @@ pub fn uint256_signed_nn( let a_high = vm.get_integer((a_addr + 1_usize)?)?; //Main logic //memory[ap] = 1 if 0 <= (ids.a.high % PRIME) < 2 ** 127 else 0 - let result: Felt = if !a_high.is_negative() && a_high.as_ref() <= &Felt::new(i128::MAX) { - Felt::one() + let result: Felt252 = if !a_high.is_negative() && a_high.as_ref() <= &Felt252::new(i128::MAX) { + Felt252::one() } else { - Felt::zero() + Felt252::zero() }; insert_value_into_ap(vm, result) } @@ -200,10 +200,10 @@ pub fn uint256_unsigned_div_rem( //a and div will always be positive numbers //Then, Rust div_rem equals Python divmod let (quotient, remainder) = div_rem(a, div); - let quotient_low = "ient & &Felt::new(u128::MAX); + let quotient_low = "ient & &Felt252::new(u128::MAX); let quotient_high = quotient.shr(128); - let remainder_low = &remainder & &Felt::new(u128::MAX); + let remainder_low = &remainder & &Felt252::new(u128::MAX); let remainder_high = remainder.shr(128); //Insert ids.quotient.low @@ -295,8 +295,8 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 12)) && - y == MaybeRelocatable::from(Felt::new(2)) && - z == MaybeRelocatable::from(Felt::zero()) + y == MaybeRelocatable::from(Felt252::new(2)) && + z == MaybeRelocatable::from(Felt252::zero()) ); } @@ -369,7 +369,7 @@ mod tests { z ) )) if x == MaybeRelocatable::from((1, 10)) && - y == MaybeRelocatable::from(Felt::zero()) && + y == MaybeRelocatable::from(Felt252::zero()) && z == MaybeRelocatable::from(felt_str!("7249717543555297151")) ); } @@ -438,7 +438,7 @@ mod tests { z, ) )) if x == MaybeRelocatable::from((1, 5)) && - y == MaybeRelocatable::from(Felt::one()) && + y == MaybeRelocatable::from(Felt252::one()) && z == MaybeRelocatable::from(felt_str!("48805497317890012913")) ); } @@ -511,8 +511,8 @@ mod tests { z, ) )) if x == MaybeRelocatable::from((1, 5)) && - y == MaybeRelocatable::from(Felt::new(55)) && - z == MaybeRelocatable::from(Felt::one()) + y == MaybeRelocatable::from(Felt252::new(55)) && + z == MaybeRelocatable::from(Felt252::one()) ); } @@ -569,8 +569,8 @@ mod tests { z, ) )) if x == MaybeRelocatable::from((1, 10)) && - y == MaybeRelocatable::from(Felt::zero()) && - z == MaybeRelocatable::from(Felt::new(10)) + y == MaybeRelocatable::from(Felt252::zero()) && + z == MaybeRelocatable::from(Felt252::new(10)) ); } } diff --git a/src/hint_processor/builtin_hint_processor/usort.rs b/src/hint_processor/builtin_hint_processor/usort.rs index f85cbfa3a0..5ee4640517 100644 --- a/src/hint_processor/builtin_hint_processor/usort.rs +++ b/src/hint_processor/builtin_hint_processor/usort.rs @@ -11,11 +11,11 @@ use crate::{ types::exec_scope::ExecutionScopes, vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; -use felt::Felt; +use felt::Felt252; use num_traits::{ToPrimitive, Zero}; pub fn usort_enter_scope(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { - if let Ok(usort_max_size) = exec_scopes.get::("usort_max_size") { + if let Ok(usort_max_size) = exec_scopes.get::("usort_max_size") { let boxed_max_size: Box = Box::new(usort_max_size); exec_scopes.enter_scope(HashMap::from([( "usort_max_size".to_string(), @@ -46,8 +46,8 @@ pub fn usort_body( )); } } - let mut positions_dict: HashMap> = HashMap::new(); - let mut output: Vec = Vec::new(); + let mut positions_dict: HashMap> = HashMap::new(); + let mut output: Vec = Vec::new(); for i in 0..input_len_u64 { let val = vm.get_integer((input_ptr + i as usize)?)?.into_owned(); if let Err(output_index) = output.binary_search(&val) { @@ -70,12 +70,12 @@ pub fn usort_body( } for (i, repetition_amount) in multiplicities.into_iter().enumerate() { - vm.insert_value((multiplicities_base + i)?, Felt::new(repetition_amount))?; + vm.insert_value((multiplicities_base + i)?, Felt252::new(repetition_amount))?; } insert_value_from_var_name( "output_len", - Felt::new(output_len), + Felt252::new(output_len), vm, ids_data, ap_tracking, @@ -99,12 +99,12 @@ pub fn verify_usort( ) -> Result<(), HintError> { let value = get_integer_from_var_name("value", vm, ids_data, ap_tracking)?.clone(); let mut positions = exec_scopes - .get_mut_dict_ref::>("positions_dict")? + .get_mut_dict_ref::>("positions_dict")? .remove(value.as_ref()) .ok_or(HintError::UnexpectedPositionsDictFail)?; positions.reverse(); exec_scopes.insert_value("positions", positions); - exec_scopes.insert_value("last_pos", Felt::zero()); + exec_scopes.insert_value("last_pos", Felt252::zero()); Ok(()) } @@ -127,9 +127,9 @@ pub fn verify_multiplicity_body( .get_mut_list_ref::("positions")? .pop() .ok_or(HintError::CouldntPopPositions)?; - let pos_diff = Felt::new(current_pos) - exec_scopes.get::("last_pos")?; + let pos_diff = Felt252::new(current_pos) - exec_scopes.get::("last_pos")?; insert_value_from_var_name("next_item_index", pos_diff, vm, ids_data, ap_tracking)?; - exec_scopes.insert_value("last_pos", Felt::new(current_pos + 1)); + exec_scopes.insert_value("last_pos", Felt252::new(current_pos + 1)); Ok(()) } @@ -177,7 +177,7 @@ mod tests { let mut exec_scopes = scope![("usort_max_size", 1_u64)]; assert_matches!( run_hint!(vm, ids_data, USORT_BODY, &mut exec_scopes), - Err(HintError::UsortOutOfRange(1, x)) if x == Felt::new(5_i32) + Err(HintError::UsortOutOfRange(1, x)) if x == Felt252::new(5_i32) ); } } diff --git a/src/hint_processor/hint_processor_definition.rs b/src/hint_processor/hint_processor_definition.rs index 5ba8335953..294870dd4f 100644 --- a/src/hint_processor/hint_processor_definition.rs +++ b/src/hint_processor/hint_processor_definition.rs @@ -11,7 +11,7 @@ use crate::vm::errors::vm_errors::VirtualMachineError; use crate::vm::vm_core::VirtualMachine; use super::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; -use felt::Felt; +use felt::Felt252; pub trait HintProcessor { //Executes the hint which's data is provided by a dynamic structure previously created by compile_hint @@ -26,7 +26,7 @@ pub trait HintProcessor { //Data structure that can be downcasted to the structure generated by compile_hint hint_data: &Box, //Constant values extracted from the program specification. - constants: &HashMap, + constants: &HashMap, ) -> Result<(), HintError>; //Transforms hint data outputed by the VM into whichever format will be later used by execute_hint diff --git a/src/hint_processor/hint_processor_utils.rs b/src/hint_processor/hint_processor_utils.rs index 894e72be5c..1df0a373e0 100644 --- a/src/hint_processor/hint_processor_utils.rs +++ b/src/hint_processor/hint_processor_utils.rs @@ -11,7 +11,7 @@ use crate::{ }; use super::hint_processor_definition::HintReference; -use felt::Felt; +use felt::Felt252; use num_traits::ToPrimitive; ///Inserts value into the address of the given ids variable @@ -32,7 +32,7 @@ pub fn get_integer_from_reference<'a>( vm: &'a VirtualMachine, hint_reference: &'a HintReference, ap_tracking: &ApTracking, -) -> Result, HintError> { +) -> Result, HintError> { // if the reference register is none, this means it is an immediate value and we // should return that value. @@ -133,16 +133,16 @@ fn apply_ap_tracking_correction( (ap - ap_diff).ok() } -//Tries to convert a Felt value to usize -pub fn felt_to_usize(felt: &Felt) -> Result { +//Tries to convert a Felt252 value to usize +pub fn felt_to_usize(felt: &Felt252) -> Result { felt.to_usize() - .ok_or_else(|| MathError::FeltToUsizeConversion(felt.clone())) + .ok_or_else(|| MathError::Felt252ToUsizeConversion(felt.clone())) } -///Tries to convert a Felt value to u32 -pub fn felt_to_u32(felt: &Felt) -> Result { +///Tries to convert a Felt252 value to u32 +pub fn felt_to_u32(felt: &Felt252) -> Result { felt.to_u32() - .ok_or_else(|| MathError::FeltToU32Conversion(felt.clone())) + .ok_or_else(|| MathError::Felt252ToU32Conversion(felt.clone())) } fn get_offset_value_reference( @@ -198,13 +198,13 @@ mod tests { let mut vm = vm!(); vm.segments = segments![((1, 0), 0)]; let mut hint_ref = HintReference::new(0, 0, false, true); - hint_ref.offset1 = OffsetValue::Immediate(Felt::new(2)); + hint_ref.offset1 = OffsetValue::Immediate(Felt252::new(2)); assert_eq!( get_integer_from_reference(&vm, &hint_ref, &ApTracking::new()) .expect("Unexpected get integer fail") .into_owned(), - Felt::new(2) + Felt252::new(2) ); } @@ -288,7 +288,7 @@ mod tests { let mut vm = vm!(); vm.segments = segments![((1, 0), (4, 0))]; let mut hint_reference = HintReference::new(0, 0, false, false); - hint_reference.offset1 = OffsetValue::Immediate(Felt::new(2_i32)); + hint_reference.offset1 = OffsetValue::Immediate(Felt252::new(2_i32)); assert!(compute_addr_from_reference(&hint_reference, &vm, &ApTracking::new()).is_none()); } diff --git a/src/math_utils.rs b/src/math_utils.rs index 0efd4293b5..15c6978ddf 100644 --- a/src/math_utils.rs +++ b/src/math_utils.rs @@ -1,6 +1,6 @@ use crate::stdlib::ops::Shr; use crate::types::errors::math_errors::MathError; -use felt::Felt; +use felt::Felt252; use num_bigint::{BigInt, BigUint}; use num_integer::Integer; use num_traits::{One, Signed, Zero}; @@ -35,7 +35,7 @@ pub fn isqrt(n: &BigUint) -> Result { } /// Performs integer division between x and y; fails if x is not divisible by y. -pub fn safe_div(x: &Felt, y: &Felt) -> Result { +pub fn safe_div(x: &Felt252, y: &Felt252) -> Result { if y.is_zero() { return Err(MathError::DividedByZero); } @@ -234,29 +234,29 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div() { - let x = Felt::new(26); - let y = Felt::new(13); - assert_matches!(safe_div(&x, &y), Ok(i) if i == Felt::new(2)); + let x = Felt252::new(26); + let y = Felt252::new(13); + assert_matches!(safe_div(&x, &y), Ok(i) if i == Felt252::new(2)); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_non_divisor() { - let x = Felt::new(25); - let y = Felt::new(4); + let x = Felt252::new(25); + let y = Felt252::new(4); let result = safe_div(&x, &y); assert_matches!( result, Err(MathError::SafeDivFail( i, j - )) if i == Felt::new(25) && j == Felt::new(4)); + )) if i == Felt252::new(25) && j == Felt252::new(4)); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn compute_safe_div_by_zero() { - let x = Felt::new(25); - let y = Felt::zero(); + let x = Felt252::new(25); + let y = Felt252::zero(); let result = safe_div(&x, &y); assert_matches!(result, Err(MathError::DividedByZero)); } diff --git a/src/serde/deserialize_program.rs b/src/serde/deserialize_program.rs index 38216609fe..c15119db0b 100644 --- a/src/serde/deserialize_program.rs +++ b/src/serde/deserialize_program.rs @@ -11,7 +11,7 @@ use crate::{ OUTPUT_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, }, }; -use felt::{Felt, PRIME_STR}; +use felt::{Felt252, PRIME_STR}; use num_traits::Num; use serde::{de, de::MapAccess, de::SeqAccess, Deserialize, Deserializer, Serialize}; use serde_json::Number; @@ -98,7 +98,7 @@ pub struct Identifier { pub type_: Option, #[serde(default)] #[serde(deserialize_with = "felt_from_number")] - pub value: Option, + pub value: Option, pub full_name: Option, pub members: Option>, @@ -152,12 +152,12 @@ pub struct HintLocation { pub n_prefix_newlines: u32, } -fn felt_from_number<'de, D>(deserializer: D) -> Result, D::Error> +fn felt_from_number<'de, D>(deserializer: D) -> Result, D::Error> where D: Deserializer<'de>, { let n = Number::deserialize(deserializer)?; - Ok(Felt::parse_bytes(n.to_string().as_bytes(), 10)) + Ok(Felt252::parse_bytes(n.to_string().as_bytes(), 10)) } #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] @@ -176,7 +176,7 @@ pub struct Reference { #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] pub enum OffsetValue { - Immediate(Felt), + Immediate(Felt252), Value(i32), Reference(Register, i32, bool), } @@ -208,10 +208,10 @@ impl ValueAddress { } } -struct FeltVisitor; +struct Felt252Visitor; -impl<'de> de::Visitor<'de> for FeltVisitor { - type Value = Felt; +impl<'de> de::Visitor<'de> for Felt252Visitor { + type Value = Felt252; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("Could not deserialize hexadecimal string") @@ -225,7 +225,7 @@ impl<'de> de::Visitor<'de> for FeltVisitor { if let Some(no_prefix_hex) = value.strip_prefix("0x") { // Add padding if necessary let no_prefix_hex = deserialize_utils::maybe_add_padding(no_prefix_hex.to_string()); - Ok(Felt::from_str_radix(&no_prefix_hex, 16).map_err(de::Error::custom)?) + Ok(Felt252::from_str_radix(&no_prefix_hex, 16).map_err(de::Error::custom)?) } else { Err(String::from("hex prefix error")).map_err(de::Error::custom) } @@ -252,7 +252,7 @@ impl<'de> de::Visitor<'de> for MaybeRelocatableVisitor { // Add padding if necessary let no_prefix_hex = deserialize_utils::maybe_add_padding(no_prefix_hex.to_string()); data.push(MaybeRelocatable::Int( - Felt::from_str_radix(&no_prefix_hex, 16).map_err(de::Error::custom)?, + Felt252::from_str_radix(&no_prefix_hex, 16).map_err(de::Error::custom)?, )); } else { return Err(String::from("hex prefix error")).map_err(de::Error::custom); @@ -308,8 +308,8 @@ impl<'de> de::Visitor<'de> for ValueAddressVisitor { } } -pub fn deserialize_felt_hex<'de, D: Deserializer<'de>>(d: D) -> Result { - d.deserialize_str(FeltVisitor) +pub fn deserialize_felt_hex<'de, D: Deserializer<'de>>(d: D) -> Result { + d.deserialize_str(Felt252Visitor) } pub fn deserialize_array_of_bigint_hex<'de, D: Deserializer<'de>>( @@ -570,12 +570,12 @@ mod tests { let program_json: ProgramJson = serde_json::from_str(valid_json).unwrap(); let data: Vec = vec![ - MaybeRelocatable::Int(Felt::new(5189976364521848832_i64)), - MaybeRelocatable::Int(Felt::new(1000_i64)), - MaybeRelocatable::Int(Felt::new(5189976364521848832_i64)), - MaybeRelocatable::Int(Felt::new(2000_i64)), - MaybeRelocatable::Int(Felt::new(5201798304953696256_i64)), - MaybeRelocatable::Int(Felt::new(2345108766317314046_i64)), + MaybeRelocatable::Int(Felt252::new(5189976364521848832_i64)), + MaybeRelocatable::Int(Felt252::new(1000_i64)), + MaybeRelocatable::Int(Felt252::new(5189976364521848832_i64)), + MaybeRelocatable::Int(Felt252::new(2000_i64)), + MaybeRelocatable::Int(Felt252::new(5201798304953696256_i64)), + MaybeRelocatable::Int(Felt252::new(2345108766317314046_i64)), ]; let mut hints: HashMap> = HashMap::new(); @@ -650,7 +650,7 @@ mod tests { pc: Some(0), value_address: ValueAddress { offset1: OffsetValue::Reference(Register::FP, -3, true), - offset2: OffsetValue::Immediate(Felt::new(2)), + offset2: OffsetValue::Immediate(Felt252::new(2)), dereference: false, value_type: "felt".to_string(), }, @@ -761,12 +761,12 @@ mod tests { let builtins: Vec = Vec::new(); let data: Vec = vec![ - MaybeRelocatable::Int(Felt::new(5189976364521848832_i64)), - MaybeRelocatable::Int(Felt::new(1000)), - MaybeRelocatable::Int(Felt::new(5189976364521848832_i64)), - MaybeRelocatable::Int(Felt::new(2000)), - MaybeRelocatable::Int(Felt::new(5201798304953696256_i64)), - MaybeRelocatable::Int(Felt::new(2345108766317314046_i64)), + MaybeRelocatable::Int(Felt252::new(5189976364521848832_i64)), + MaybeRelocatable::Int(Felt252::new(1000)), + MaybeRelocatable::Int(Felt252::new(5189976364521848832_i64)), + MaybeRelocatable::Int(Felt252::new(2000)), + MaybeRelocatable::Int(Felt252::new(5201798304953696256_i64)), + MaybeRelocatable::Int(Felt252::new(2345108766317314046_i64)), ]; let mut hints: HashMap> = HashMap::new(); @@ -823,12 +823,12 @@ mod tests { let builtins: Vec = Vec::new(); let data: Vec = vec![ - MaybeRelocatable::Int(Felt::new(5189976364521848832_i64)), - MaybeRelocatable::Int(Felt::new(1000)), - MaybeRelocatable::Int(Felt::new(5189976364521848832_i64)), - MaybeRelocatable::Int(Felt::new(2000)), - MaybeRelocatable::Int(Felt::new(5201798304953696256_i64)), - MaybeRelocatable::Int(Felt::new(2345108766317314046_i64)), + MaybeRelocatable::Int(Felt252::new(5189976364521848832_i64)), + MaybeRelocatable::Int(Felt252::new(1000)), + MaybeRelocatable::Int(Felt252::new(5189976364521848832_i64)), + MaybeRelocatable::Int(Felt252::new(2000)), + MaybeRelocatable::Int(Felt252::new(5201798304953696256_i64)), + MaybeRelocatable::Int(Felt252::new(2345108766317314046_i64)), ]; let mut hints: HashMap> = HashMap::new(); @@ -936,7 +936,7 @@ mod tests { Identifier { pc: None, type_: Some(String::from("const")), - value: Some(Felt::new(3)), + value: Some(Felt252::new(3)), full_name: None, members: None, cairo_type: None, @@ -947,7 +947,7 @@ mod tests { Identifier { pc: None, type_: Some(String::from("const")), - value: Some(Felt::zero()), + value: Some(Felt252::zero()), full_name: None, members: None, cairo_type: None, diff --git a/src/serde/deserialize_utils.rs b/src/serde/deserialize_utils.rs index e4c659b901..5c30fcb31b 100644 --- a/src/serde/deserialize_utils.rs +++ b/src/serde/deserialize_utils.rs @@ -4,7 +4,7 @@ use crate::{ serde::deserialize_program::{OffsetValue, ValueAddress}, types::instruction::Register, }; -use felt::{Felt, ParseFeltError}; +use felt::{Felt252, ParseFeltError}; use nom::{ branch::alt, bytes::{ @@ -23,7 +23,7 @@ use parse_hyperlinks::take_until_unbalanced; #[derive(Debug, PartialEq, Eq)] pub enum ReferenceParseError { IntError(ParseIntError), - FeltError(ParseFeltError), + Felt252Error(ParseFeltError), InvalidStringError(String), } @@ -34,8 +34,8 @@ impl fmt::Display for ReferenceParseError { write!(f, "Int parsing error: ")?; error.fmt(f) } - ReferenceParseError::FeltError(error) => { - write!(f, "Felt parsing error: ")?; + ReferenceParseError::Felt252Error(error) => { + write!(f, "Felt252 parsing error: ")?; error.fmt(f) } ReferenceParseError::InvalidStringError(error) => { @@ -187,13 +187,13 @@ pub fn parse_value(input: &str) -> IResult<&str, ValueAddress> { let (offset1, offset2) = if struct_ == "felt" && indirection_level.is_empty() { let offset1 = match fst_offset { OffsetValue::Immediate(imm) => OffsetValue::Immediate(imm), - OffsetValue::Value(val) => OffsetValue::Immediate(Felt::new(val)), + OffsetValue::Value(val) => OffsetValue::Immediate(Felt252::new(val)), OffsetValue::Reference(reg, val, refe) => OffsetValue::Reference(reg, val, refe), }; let offset2 = match snd_offset { OffsetValue::Immediate(imm) => OffsetValue::Immediate(imm), - OffsetValue::Value(val) => OffsetValue::Immediate(Felt::new(val)), + OffsetValue::Value(val) => OffsetValue::Immediate(Felt252::new(val)), OffsetValue::Reference(reg, val, refe) => OffsetValue::Reference(reg, val, refe), }; @@ -424,7 +424,7 @@ mod tests { "", ValueAddress { offset1: OffsetValue::Reference(Register::AP, 0_i32, true), - offset2: OffsetValue::Immediate(Felt::one()), + offset2: OffsetValue::Immediate(Felt252::one()), dereference: true, value_type: "felt".to_string(), } @@ -503,8 +503,8 @@ mod tests { Ok(( "", ValueAddress { - offset1: OffsetValue::Immediate(Felt::new(825323_i32)), - offset2: OffsetValue::Immediate(Felt::zero()), + offset1: OffsetValue::Immediate(Felt252::new(825323_i32)), + offset2: OffsetValue::Immediate(Felt252::zero()), dereference: false, value_type: "felt".to_string(), } diff --git a/src/types/errors/math_errors.rs b/src/types/errors/math_errors.rs index 4cb1b71ace..07cec81994 100644 --- a/src/types/errors/math_errors.rs +++ b/src/types/errors/math_errors.rs @@ -1,4 +1,4 @@ -use felt::Felt; +use felt::Felt252; use num_bigint::{BigInt, BigUint}; #[cfg(feature = "std")] @@ -12,9 +12,9 @@ use crate::types::relocatable::{MaybeRelocatable, Relocatable}; pub enum MathError { // Math functions #[error("Can't calculate the square root of negative number: {0})")] - SqrtNegative(Felt), + SqrtNegative(Felt252), #[error("{0} is not divisible by {1}")] - SafeDivFail(Felt, Felt), + SafeDivFail(Felt252, Felt252), #[error("{0} is not divisible by {1}")] SafeDivFailBigInt(BigInt, BigInt), #[error("{0} is not divisible by {1}")] @@ -29,11 +29,11 @@ pub enum MathError { FailedToGetSqrt(BigUint), // Relocatable Operations #[error("Cant convert felt: {0} to Relocatable")] - FeltToRelocatable(Felt), + Felt252ToRelocatable(Felt252), #[error("Operation failed: {0} - {1}, offsets cant be negative")] RelocatableSubNegOffset(Relocatable, usize), #[error("Operation failed: {0} + {1}, maximum offset value exceeded")] - RelocatableAddFeltOffsetExceeded(Relocatable, Felt), + RelocatableAddFelt252OffsetExceeded(Relocatable, Felt252), #[error("Operation failed: {0} + {1}, maximum offset value exceeded")] RelocatableAddUsizeOffsetExceeded(Relocatable, usize), #[error("Operation failed: {0} + {1}, can't add two relocatable values")] @@ -45,14 +45,14 @@ pub enum MathError { )] DivModWrongType(MaybeRelocatable, MaybeRelocatable), #[error("Operation failed {0} - {1}, can't subtract a relocatable value from an integer")] - SubRelocatableFromInt(Felt, Relocatable), + SubRelocatableFromInt(Felt252, Relocatable), // Type conversions - #[error("Conversion to i32 failed for Felt {0}")] - FeltToI32Conversion(Felt), - #[error("Conversion to u32 failed for Felt {0}")] - FeltToU32Conversion(Felt), - #[error("Conversion to usize failed for Felt {0}")] - FeltToUsizeConversion(Felt), - #[error("Conversion to u64 failed for Felt {0}")] - FeltToU64Conversion(Felt), + #[error("Conversion to i32 failed for Felt252 {0}")] + Felt252ToI32Conversion(Felt252), + #[error("Conversion to u32 failed for Felt252 {0}")] + Felt252ToU32Conversion(Felt252), + #[error("Conversion to usize failed for Felt252 {0}")] + Felt252ToUsizeConversion(Felt252), + #[error("Conversion to u64 failed for Felt252 {0}")] + Felt252ToU64Conversion(Felt252), } diff --git a/src/types/exec_scope.rs b/src/types/exec_scope.rs index 941525e26b..79a22a3027 100644 --- a/src/types/exec_scope.rs +++ b/src/types/exec_scope.rs @@ -188,7 +188,7 @@ impl Default for ExecutionScopes { mod tests { use super::*; use assert_matches::assert_matches; - use felt::Felt; + use felt::Felt252; use num_traits::One; #[cfg(target_arch = "wasm32")] @@ -205,7 +205,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_local_variables_test() { let var_name = String::from("a"); - let var_value: Box = Box::new(Felt::new(2)); + let var_value: Box = Box::new(Felt252::new(2)); let scope = HashMap::from([(var_name, var_value)]); @@ -217,8 +217,8 @@ mod tests { .unwrap() .get("a") .unwrap() - .downcast_ref::(), - Some(&Felt::new(2)) + .downcast_ref::(), + Some(&Felt252::new(2)) ); } @@ -226,14 +226,14 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn enter_new_scope_test() { let var_name = String::from("a"); - let var_value: Box = Box::new(Felt::new(2_i32)); + let var_value: Box = Box::new(Felt252::new(2_i32)); let new_scope = HashMap::from([(var_name, var_value)]); let mut scopes = ExecutionScopes { data: vec![HashMap::from([( String::from("b"), - (Box::new(Felt::one()) as Box), + (Box::new(Felt252::one()) as Box), )])], }; @@ -244,8 +244,8 @@ mod tests { .unwrap() .get("b") .unwrap() - .downcast_ref::(), - Some(&Felt::one()) + .downcast_ref::(), + Some(&Felt252::one()) ); scopes.enter_scope(new_scope); @@ -260,8 +260,8 @@ mod tests { .unwrap() .get("a") .unwrap() - .downcast_ref::(), - Some(&Felt::new(2)) + .downcast_ref::(), + Some(&Felt252::new(2)) ); } @@ -269,7 +269,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn exit_scope_test() { let var_name = String::from("a"); - let var_value: Box = Box::new(Felt::new(2)); + let var_value: Box = Box::new(Felt252::new(2)); let new_scope = HashMap::from([(var_name, var_value)]); @@ -286,8 +286,8 @@ mod tests { .unwrap() .get("a") .unwrap() - .downcast_ref::(), - Some(&Felt::new(2)) + .downcast_ref::(), + Some(&Felt252::new(2)) ); // exit the current scope @@ -305,7 +305,7 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn assign_local_variable_test() { - let var_value: Box = Box::new(Felt::new(2)); + let var_value: Box = Box::new(Felt252::new(2)); let mut scopes = ExecutionScopes::new(); @@ -318,8 +318,8 @@ mod tests { .unwrap() .get("a") .unwrap() - .downcast_ref::(), - Some(&Felt::new(2)) + .downcast_ref::(), + Some(&Felt252::new(2)) ); } @@ -327,13 +327,13 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn re_assign_local_variable_test() { let var_name = String::from("a"); - let var_value: Box = Box::new(Felt::new(2)); + let var_value: Box = Box::new(Felt252::new(2)); let scope = HashMap::from([(var_name, var_value)]); let mut scopes = ExecutionScopes { data: vec![scope] }; - let var_value_new: Box = Box::new(Felt::new(3)); + let var_value_new: Box = Box::new(Felt252::new(3)); scopes.assign_or_update_variable("a", var_value_new); @@ -344,8 +344,8 @@ mod tests { .unwrap() .get("a") .unwrap() - .downcast_ref::(), - Some(&Felt::new(3)) + .downcast_ref::(), + Some(&Felt252::new(3)) ); } @@ -353,7 +353,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn delete_local_variable_test() { let var_name = String::from("a"); - let var_value: Box = Box::new(Felt::new(2)); + let var_value: Box = Box::new(Felt252::new(2)); let scope = HashMap::from([(var_name, var_value)]); @@ -431,14 +431,14 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_mut_int_ref_test() { - let bigint: Box = Box::new(Felt::new(12)); + let bigint: Box = Box::new(Felt252::new(12)); let mut scopes = ExecutionScopes::new(); scopes.assign_or_update_variable("bigint", bigint); assert_matches!( - scopes.get_mut_ref::("bigint"), - Ok(x) if x == &mut Felt::new(12) + scopes.get_mut_ref::("bigint"), + Ok(x) if x == &mut Felt252::new(12) ); } diff --git a/src/types/instruction.rs b/src/types/instruction.rs index d3d43866e9..cd74eaa35e 100644 --- a/src/types/instruction.rs +++ b/src/types/instruction.rs @@ -1,4 +1,4 @@ -use felt::Felt; +use felt::Felt252; use num_traits::ToPrimitive; use serde::{Deserialize, Serialize}; @@ -15,7 +15,7 @@ pub struct Instruction { pub off0: isize, pub off1: isize, pub off2: isize, - pub imm: Option, + pub imm: Option, pub dst_register: Register, pub op0_register: Register, pub op1_addr: Op1Addr, @@ -83,7 +83,7 @@ impl Instruction { } // Returns True if the given instruction looks like a call instruction. -pub(crate) fn is_call_instruction(encoded_instruction: &Felt, imm: Option<&Felt>) -> bool { +pub(crate) fn is_call_instruction(encoded_instruction: &Felt252, imm: Option<&Felt252>) -> bool { let encoded_i64_instruction: i64 = match encoded_instruction.to_i64() { Some(num) => num, None => return false, @@ -109,25 +109,28 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_call_instruction_true() { - let encoded_instruction = Felt::new(1226245742482522112_i64); + let encoded_instruction = Felt252::new(1226245742482522112_i64); assert!(is_call_instruction( &encoded_instruction, - Some(&Felt::new(2)) + Some(&Felt252::new(2)) )); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_call_instruction_false() { - let encoded_instruction = Felt::new(4612671187288031229_i64); + let encoded_instruction = Felt252::new(4612671187288031229_i64); assert!(!is_call_instruction(&encoded_instruction, None)); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn instruction_size() { - let encoded_instruction = Felt::new(1226245742482522112_i64); - let instruction = - decode_instruction(encoded_instruction.to_i64().unwrap(), Some(&Felt::new(2))).unwrap(); + let encoded_instruction = Felt252::new(1226245742482522112_i64); + let instruction = decode_instruction( + encoded_instruction.to_i64().unwrap(), + Some(&Felt252::new(2)), + ) + .unwrap(); assert_eq!(instruction.size(), 2); } } diff --git a/src/types/program.rs b/src/types/program.rs index f96913e287..75b9f3de0e 100644 --- a/src/types/program.rs +++ b/src/types/program.rs @@ -7,7 +7,7 @@ use crate::{ }, types::{errors::program_errors::ProgramError, relocatable::MaybeRelocatable}, }; -use felt::{Felt, PRIME_STR}; +use felt::{Felt252, PRIME_STR}; use serde::{Deserialize, Serialize}; #[cfg(feature = "std")] @@ -18,7 +18,7 @@ pub struct Program { pub builtins: Vec, pub prime: String, pub data: Vec, - pub constants: HashMap, + pub constants: HashMap, pub main: Option, //start and end labels will only be used in proof-mode pub start: Option, @@ -187,7 +187,7 @@ mod tests { Identifier { pc: None, type_: Some(String::from("const")), - value: Some(Felt::zero()), + value: Some(Felt252::zero()), full_name: None, members: None, cairo_type: None, @@ -213,7 +213,7 @@ mod tests { assert_eq!(program.identifiers, identifiers); assert_eq!( program.constants, - [("__main__.main.SIZEOF_LOCALS", Felt::zero())] + [("__main__.main.SIZEOF_LOCALS", Felt252::zero())] .into_iter() .map(|(key, value)| (key.to_string(), value)) .collect::>(), @@ -349,7 +349,7 @@ mod tests { Identifier { pc: None, type_: Some(String::from("const")), - value: Some(Felt::zero()), + value: Some(Felt252::zero()), full_name: None, members: None, cairo_type: None, @@ -449,7 +449,7 @@ mod tests { Identifier { pc: None, type_: Some(String::from("const")), - value: Some(Felt::zero()), + value: Some(Felt252::zero()), full_name: None, members: None, cairo_type: None, @@ -474,7 +474,7 @@ mod tests { .unwrap(); let constants = [ - ("__main__.compare_abs_arrays.SIZEOF_LOCALS", Felt::zero()), + ("__main__.compare_abs_arrays.SIZEOF_LOCALS", Felt252::zero()), ( "starkware.cairo.common.cairo_keccak.packed_keccak.ALL_ONES", felt_str!( @@ -483,7 +483,7 @@ mod tests { ), ( "starkware.cairo.common.cairo_keccak.packed_keccak.BLOCK_SIZE", - Felt::new(3), + Felt252::new(3), ), ( "starkware.cairo.common.alloc.alloc.SIZEOF_LOCALS", diff --git a/src/types/relocatable.rs b/src/types/relocatable.rs index 36719ab182..295691f9bf 100644 --- a/src/types/relocatable.rs +++ b/src/types/relocatable.rs @@ -7,7 +7,7 @@ use crate::stdlib::{ use crate::{ relocatable, types::errors::math_errors::MathError, vm::errors::memory_errors::MemoryError, }; -use felt::Felt; +use felt::Felt252; use num_traits::{ToPrimitive, Zero}; use serde::{Deserialize, Serialize}; @@ -20,7 +20,7 @@ pub struct Relocatable { #[derive(Eq, Hash, PartialEq, PartialOrd, Clone, Debug, Serialize, Deserialize)] pub enum MaybeRelocatable { RelocatableValue(Relocatable), - Int(Felt), + Int(Felt252), } impl From<(isize, usize)> for Relocatable { @@ -40,12 +40,12 @@ impl From<(isize, usize)> for MaybeRelocatable { impl From for MaybeRelocatable { fn from(num: usize) -> Self { - MaybeRelocatable::Int(Felt::new(num)) + MaybeRelocatable::Int(Felt252::new(num)) } } -impl From for MaybeRelocatable { - fn from(num: Felt) -> Self { +impl From for MaybeRelocatable { + fn from(num: Felt252) -> Self { MaybeRelocatable::Int(num) } } @@ -62,8 +62,8 @@ impl From<&Relocatable> for Relocatable { } } -impl From<&Felt> for MaybeRelocatable { - fn from(val: &Felt) -> Self { +impl From<&Felt252> for MaybeRelocatable { + fn from(val: &Felt252) -> Self { MaybeRelocatable::Int(val.clone()) } } @@ -116,13 +116,13 @@ impl Add for Relocatable { } } } -impl Add<&Felt> for Relocatable { +impl Add<&Felt252> for Relocatable { type Output = Result; - fn add(self, other: &Felt) -> Result { + fn add(self, other: &Felt252) -> Result { let big_offset = other + self.offset; let new_offset = big_offset .to_usize() - .ok_or_else(|| MathError::RelocatableAddFeltOffsetExceeded(self, other.clone()))?; + .ok_or_else(|| MathError::RelocatableAddFelt252OffsetExceeded(self, other.clone()))?; Ok(Relocatable { segment_index: self.segment_index, offset: new_offset, @@ -190,20 +190,20 @@ impl TryFrom<&MaybeRelocatable> for Relocatable { fn try_from(other: &MaybeRelocatable) -> Result { match other { MaybeRelocatable::RelocatableValue(rel) => Ok(*rel), - MaybeRelocatable::Int(num) => Err(MathError::FeltToRelocatable(num.clone())), + MaybeRelocatable::Int(num) => Err(MathError::Felt252ToRelocatable(num.clone())), } } } impl MaybeRelocatable { - /// Adds a Felt to self - pub fn add_int(&self, other: &Felt) -> Result { + /// Adds a Felt252 to self + pub fn add_int(&self, other: &Felt252) -> Result { match *self { MaybeRelocatable::Int(ref value) => Ok(MaybeRelocatable::Int(value + other)), MaybeRelocatable::RelocatableValue(ref rel) => { let big_offset = other + rel.offset; let new_offset = big_offset.to_usize().ok_or_else(|| { - MathError::RelocatableAddFeltOffsetExceeded(*rel, other.clone()) + MathError::RelocatableAddFelt252OffsetExceeded(*rel, other.clone()) })?; Ok(MaybeRelocatable::RelocatableValue(Relocatable { segment_index: rel.segment_index, @@ -252,7 +252,7 @@ impl MaybeRelocatable { MaybeRelocatable::RelocatableValue(rel_b), ) => { if rel_a.segment_index == rel_b.segment_index { - return Ok(MaybeRelocatable::from(Felt::new((*rel_a - *rel_b)?))); + return Ok(MaybeRelocatable::from(Felt252::new((*rel_a - *rel_b)?))); } Err(MathError::RelocatableSubDiffIndex(*rel_a, *rel_b)) } @@ -260,7 +260,7 @@ impl MaybeRelocatable { Ok(MaybeRelocatable::from(( rel_a.segment_index, (rel_a.offset - num_b).to_usize().ok_or_else(|| { - MathError::RelocatableAddFeltOffsetExceeded(*rel_a, num_b.clone()) + MathError::RelocatableAddFelt252OffsetExceeded(*rel_a, num_b.clone()) })?, ))) } @@ -280,14 +280,14 @@ impl MaybeRelocatable { (MaybeRelocatable::Int(val), MaybeRelocatable::Int(div)) => Ok(( MaybeRelocatable::from(val / div), // NOTE: elements on a field element always have multiplicative inverse - MaybeRelocatable::from(Felt::zero()), + MaybeRelocatable::from(Felt252::zero()), )), _ => Err(MathError::DivModWrongType(self.clone(), other.clone())), } } - /// Returns a reference to the inner value if it is a Felt, returns None otherwise. - pub fn get_int_ref(&self) -> Option<&Felt> { + /// Returns a reference to the inner value if it is a Felt252, returns None otherwise. + pub fn get_int_ref(&self) -> Option<&Felt252> { match self { MaybeRelocatable::Int(num) => Some(num), MaybeRelocatable::RelocatableValue(_) => None, @@ -314,18 +314,19 @@ impl<'a> Add for &'a Relocatable { } } -/// Turns a MaybeRelocatable into a Felt value. -/// If the value is an Int, it will extract the Felt value from it. +/// Turns a MaybeRelocatable into a Felt252 value. +/// If the value is an Int, it will extract the Felt252 value from it. /// If the value is RelocatableValue, it will relocate it according to the relocation_table pub fn relocate_value( value: MaybeRelocatable, relocation_table: &Vec, -) -> Result { +) -> Result { match value { MaybeRelocatable::Int(num) => Ok(num), - MaybeRelocatable::RelocatableValue(relocatable) => { - Ok(Felt::from(relocate_address(relocatable, relocation_table)?)) - } + MaybeRelocatable::RelocatableValue(relocatable) => Ok(Felt252::from(relocate_address( + relocatable, + relocation_table, + )?)), } } @@ -362,24 +363,24 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_int() { - let addr = MaybeRelocatable::from(Felt::new(7i32)); - let added_addr = addr.add_int(&Felt::new(2i32)); - assert_eq!(added_addr, Ok(MaybeRelocatable::Int(Felt::new(9)))); + let addr = MaybeRelocatable::from(Felt252::new(7i32)); + let added_addr = addr.add_int(&Felt252::new(2i32)); + assert_eq!(added_addr, Ok(MaybeRelocatable::Int(Felt252::new(9)))); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_usize_to_int() { - let addr = MaybeRelocatable::from(Felt::new(7_i32)); + let addr = MaybeRelocatable::from(Felt252::new(7_i32)); let added_addr = addr.add_usize(2).unwrap(); - assert_eq!(MaybeRelocatable::Int(Felt::new(9)), added_addr); + assert_eq!(MaybeRelocatable::Int(Felt252::new(9)), added_addr); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_bigint_to_relocatable() { let addr = MaybeRelocatable::RelocatableValue(relocatable!(7, 65)); - let added_addr = addr.add_int(&Felt::new(2)); + let added_addr = addr.add_int(&Felt252::new(2)); assert_eq!( added_addr, Ok(MaybeRelocatable::RelocatableValue(Relocatable { @@ -396,7 +397,7 @@ mod tests { let error = addr.add_int(&felt_str!("18446744073709551616")); assert_eq!( error, - Err(MathError::RelocatableAddFeltOffsetExceeded( + Err(MathError::RelocatableAddFelt252OffsetExceeded( relocatable!(0, 0), felt_str!("18446744073709551616") )) @@ -424,8 +425,8 @@ mod tests { "800000000000011000000000000000000000000000000000000000000000004", 16 )); - let added_addr = addr.add_int(&Felt::one()); - assert_eq!(added_addr, Ok(MaybeRelocatable::Int(Felt::new(4)))); + let added_addr = addr.add_int(&Felt252::one()); + assert_eq!(added_addr, Ok(MaybeRelocatable::Int(Felt252::new(4)))); } #[test] @@ -450,9 +451,9 @@ mod tests { let addr_a = &MaybeRelocatable::from(felt_str!( "3618502788666131213697322783095070105623107215331596699973092056135872020488" )); - let addr_b = &MaybeRelocatable::from(Felt::new(17_i32)); + let addr_b = &MaybeRelocatable::from(Felt252::new(17_i32)); let added_addr = addr_a.add(addr_b); - assert_eq!(added_addr, Ok(MaybeRelocatable::Int(Felt::new(24)))); + assert_eq!(added_addr, Ok(MaybeRelocatable::Int(Felt252::new(24)))); } #[test] @@ -474,7 +475,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_int_to_relocatable() { let addr_a = &MaybeRelocatable::from((7, 7)); - let addr_b = &MaybeRelocatable::from(Felt::new(10)); + let addr_b = &MaybeRelocatable::from(Felt252::new(10)); let added_addr = addr_a.add(addr_b); assert_eq!( added_addr, @@ -488,7 +489,7 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn add_relocatable_to_int() { - let addr_a = &MaybeRelocatable::from(Felt::new(10_i32)); + let addr_a = &MaybeRelocatable::from(Felt252::new(10_i32)); let addr_b = &MaybeRelocatable::RelocatableValue(relocatable!(7, 7)); let added_addr = addr_a.add(addr_b); assert_eq!( @@ -525,7 +526,7 @@ mod tests { let error = addr.add(&MaybeRelocatable::from(felt_str!("18446744073709551616"))); assert_eq!( error, - Err(MathError::RelocatableAddFeltOffsetExceeded( + Err(MathError::RelocatableAddFelt252OffsetExceeded( relocatable!(0, 0), felt_str!("18446744073709551616") )) @@ -543,7 +544,7 @@ mod tests { let error = addr.add(&MaybeRelocatable::RelocatableValue(relocatable)); assert_eq!( error, - Err(MathError::RelocatableAddFeltOffsetExceeded( + Err(MathError::RelocatableAddFelt252OffsetExceeded( relocatable!(0, 0), felt_str!("18446744073709551616") )) @@ -553,10 +554,10 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_int_from_int() { - let addr_a = &MaybeRelocatable::from(Felt::new(7)); - let addr_b = &MaybeRelocatable::from(Felt::new(5)); + let addr_a = &MaybeRelocatable::from(Felt252::new(7)); + let addr_b = &MaybeRelocatable::from(Felt252::new(5)); let sub_addr = addr_a.sub(addr_b); - assert_eq!(sub_addr, Ok(MaybeRelocatable::Int(Felt::new(2)))); + assert_eq!(sub_addr, Ok(MaybeRelocatable::Int(Felt252::new(2)))); } #[test] @@ -565,7 +566,7 @@ mod tests { let addr_a = &MaybeRelocatable::from((7, 17)); let addr_b = &MaybeRelocatable::from((7, 7)); let sub_addr = addr_a.sub(addr_b); - assert_eq!(sub_addr, Ok(MaybeRelocatable::Int(Felt::new(10)))); + assert_eq!(sub_addr, Ok(MaybeRelocatable::Int(Felt252::new(10)))); } #[test] @@ -587,7 +588,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_int_addr_ref_from_relocatable_addr_ref() { let addr_a = &MaybeRelocatable::from((7, 17)); - let addr_b = &MaybeRelocatable::from(Felt::new(5_i32)); + let addr_b = &MaybeRelocatable::from(Felt252::new(5_i32)); let addr_c = addr_a.sub(addr_b); assert_eq!(addr_c, Ok(MaybeRelocatable::from((7, 12)))); } @@ -596,9 +597,9 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn sub_rel_to_int_error() { assert_eq!( - MaybeRelocatable::from(Felt::new(7_i32)).sub(&MaybeRelocatable::from((7, 10))), + MaybeRelocatable::from(Felt252::new(7_i32)).sub(&MaybeRelocatable::from((7, 10))), Err(MathError::SubRelocatableFromInt( - Felt::new(7_i32), + Felt252::new(7_i32), Relocatable::from((7, 10)) )) ); @@ -607,22 +608,25 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn divmod_working() { - let value = &MaybeRelocatable::from(Felt::new(10)); - let div = &MaybeRelocatable::from(Felt::new(3)); + let value = &MaybeRelocatable::from(Felt252::new(10)); + let div = &MaybeRelocatable::from(Felt252::new(3)); let (q, r) = value.divmod(div).expect("Unexpected error in divmod"); - assert_eq!(q, MaybeRelocatable::from(Felt::new(10) / Felt::new(3))); - assert_eq!(r, MaybeRelocatable::from(Felt::zero())); + assert_eq!( + q, + MaybeRelocatable::from(Felt252::new(10) / Felt252::new(3)) + ); + assert_eq!(r, MaybeRelocatable::from(Felt252::zero())); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn divmod_bad_type() { - let value = &MaybeRelocatable::from(Felt::new(10)); + let value = &MaybeRelocatable::from(Felt252::new(10)); let div = &MaybeRelocatable::from((2, 7)); assert_eq!( value.divmod(div), Err(MathError::DivModWrongType( - MaybeRelocatable::from(Felt::new(10)), + MaybeRelocatable::from(Felt252::new(10)), MaybeRelocatable::from((2, 7)) )) ); @@ -633,7 +637,10 @@ mod tests { fn relocate_relocatable_value() { let value = MaybeRelocatable::from((2, 7)); let relocation_table = vec![1, 2, 5]; - assert_eq!(relocate_value(value, &relocation_table), Ok(Felt::new(12))); + assert_eq!( + relocate_value(value, &relocation_table), + Ok(Felt252::new(12)) + ); } #[test] @@ -672,9 +679,12 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocate_int_value() { - let value = MaybeRelocatable::from(Felt::new(7)); + let value = MaybeRelocatable::from(Felt252::new(7)); let relocation_table = vec![1, 2, 5]; - assert_eq!(relocate_value(value, &relocation_table), Ok(Felt::new(7))); + assert_eq!( + relocate_value(value, &relocation_table), + Ok(Felt252::new(7)) + ); } #[test] @@ -691,18 +701,24 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_int() { - assert_eq!(relocatable!(1, 2) + &Felt::new(4), Ok(relocatable!(1, 6))); - assert_eq!(relocatable!(3, 2) + &Felt::zero(), Ok(relocatable!(3, 2))); + assert_eq!( + relocatable!(1, 2) + &Felt252::new(4), + Ok(relocatable!(1, 6)) + ); + assert_eq!( + relocatable!(3, 2) + &Felt252::zero(), + Ok(relocatable!(3, 2)) + ); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn relocatable_add_int_mod_offset_exceeded_error() { assert_eq!( - relocatable!(0, 0) + &(Felt::new(usize::MAX) + 1_usize), - Err(MathError::RelocatableAddFeltOffsetExceeded( + relocatable!(0, 0) + &(Felt252::new(usize::MAX) + 1_usize), + Err(MathError::RelocatableAddFelt252OffsetExceeded( relocatable!(0, 0), - Felt::new(usize::MAX) + 1_usize + Felt252::new(usize::MAX) + 1_usize )) ); } @@ -798,9 +814,9 @@ mod tests { fn add_maybe_mod_offset_exceeded_error() { assert_eq!( relocatable!(1, 0) + &mayberelocatable!(usize::MAX as i128 + 1), - Err(MathError::RelocatableAddFeltOffsetExceeded( + Err(MathError::RelocatableAddFelt252OffsetExceeded( relocatable!(1, 0), - Felt::new(usize::MAX) + 1_usize + Felt252::new(usize::MAX) + 1_usize )) ); } @@ -837,7 +853,7 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn maybe_relocatable_int_display() { assert_eq!( - format!("{}", MaybeRelocatable::from(Felt::new(6))), + format!("{}", MaybeRelocatable::from(Felt252::new(6))), String::from("6") ) } diff --git a/src/utils.rs b/src/utils.rs index 301a1b6e93..8616f12476 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,7 +1,7 @@ use crate::stdlib::prelude::*; use crate::types::relocatable::Relocatable; -use felt::Felt; +use felt::Felt252; use lazy_static::lazy_static; use num_bigint::BigUint; @@ -16,7 +16,7 @@ macro_rules! relocatable { } lazy_static! { - pub static ref CAIRO_PRIME: BigUint = Felt::prime(); + pub static ref CAIRO_PRIME: BigUint = Felt252::prime(); } #[macro_export] @@ -198,7 +198,7 @@ pub mod test_utils { MaybeRelocatable::from(($val1, $val2)) }; ($val1 : expr) => { - MaybeRelocatable::from(felt::Felt::new($val1 as i128)) + MaybeRelocatable::from(felt::Felt252::new($val1 as i128)) }; } pub(crate) use mayberelocatable; @@ -550,7 +550,7 @@ mod test { vm_core::VirtualMachine, vm_memory::memory::Memory, }, }; - use felt::Felt; + use felt::Felt252; use num_traits::One; #[cfg(target_arch = "wasm32")] @@ -568,7 +568,7 @@ mod test { memory .insert( &MaybeRelocatable::from((1, 2)), - &MaybeRelocatable::from(Felt::one()), + &MaybeRelocatable::from(Felt252::one()), ) .unwrap(); memory @@ -598,7 +598,7 @@ mod test { memory .insert( &MaybeRelocatable::from((1, 2)), - &MaybeRelocatable::from(Felt::one()), + &MaybeRelocatable::from(Felt252::one()), ) .unwrap(); @@ -622,7 +622,7 @@ mod test { memory .insert( &MaybeRelocatable::from((1, 2)), - &MaybeRelocatable::from(Felt::one()), + &MaybeRelocatable::from(Felt252::one()), ) .unwrap(); @@ -769,14 +769,14 @@ mod test { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn scope_macro_test() { - let scope_from_macro = scope![("a", Felt::one())]; + let scope_from_macro = scope![("a", Felt252::one())]; let mut scope_verbose = ExecutionScopes::new(); - scope_verbose.assign_or_update_variable("a", any_box!(Felt::one())); + scope_verbose.assign_or_update_variable("a", any_box!(Felt252::one())); assert_eq!(scope_from_macro.data.len(), scope_verbose.data.len()); assert_eq!(scope_from_macro.data[0].len(), scope_verbose.data[0].len()); assert_eq!( scope_from_macro.data[0].get("a").unwrap().downcast_ref(), - Some(&Felt::one()) + Some(&Felt252::one()) ); } @@ -785,8 +785,8 @@ mod test { fn check_dictionary_pass() { let mut tracker = DictTracker::new_empty(relocatable!(2, 0)); tracker.insert_value( - &MaybeRelocatable::from(Felt::new(5)), - &MaybeRelocatable::from(Felt::new(10)), + &MaybeRelocatable::from(Felt252::new(5)), + &MaybeRelocatable::from(Felt252::new(10)), ); let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); @@ -803,8 +803,8 @@ mod test { fn check_dictionary_fail() { let mut tracker = DictTracker::new_empty(relocatable!(2, 0)); tracker.insert_value( - &MaybeRelocatable::from(Felt::new(5)), - &MaybeRelocatable::from(Felt::new(10)), + &MaybeRelocatable::from(Felt252::new(5)), + &MaybeRelocatable::from(Felt252::new(10)), ); let mut dict_manager = DictManager::new(); dict_manager.trackers.insert(2, tracker); @@ -863,7 +863,7 @@ mod test { fn dict_manager_default_macro() { let tracker = DictTracker::new_default_dict( relocatable!(2, 0), - &MaybeRelocatable::from(Felt::new(17)), + &MaybeRelocatable::from(Felt252::new(17)), None, ); let mut dict_manager = DictManager::new(); diff --git a/src/vm/context/run_context.rs b/src/vm/context/run_context.rs index 5a49f2a2ea..f1cb810a99 100644 --- a/src/vm/context/run_context.rs +++ b/src/vm/context/run_context.rs @@ -106,7 +106,7 @@ mod tests { use crate::utils::test_utils::mayberelocatable; use crate::vm::errors::memory_errors::MemoryError; use assert_matches::assert_matches; - use felt::Felt; + use felt::Felt252; #[cfg(target_arch = "wasm32")] use wasm_bindgen_test::*; @@ -402,7 +402,7 @@ mod tests { fp: 6, }; - let op0 = MaybeRelocatable::from(Felt::new(7)); + let op0 = MaybeRelocatable::from(Felt252::new(7)); assert_matches!( run_context.compute_op1_addr(&instruction, Some(&op0)), Err::(VirtualMachineError::Memory( diff --git a/src/vm/decoding/decoder.rs b/src/vm/decoding/decoder.rs index 880b478996..77364db19a 100644 --- a/src/vm/decoding/decoder.rs +++ b/src/vm/decoding/decoder.rs @@ -4,7 +4,7 @@ use crate::{ }, vm::errors::vm_errors::VirtualMachineError, }; -use felt::Felt; +use felt::Felt252; // 0| opcode|ap_update|pc_update|res_logic|op1_src|op0_reg|dst_reg // 15|14 13 12| 11 10| 9 8 7| 6 5|4 3 2| 1| 0 @@ -12,7 +12,7 @@ use felt::Felt; /// Decodes an instruction. The encoding is little endian, so flags go from bit 63 to 48. pub fn decode_instruction( encoded_instr: i64, - mut imm: Option<&Felt>, + mut imm: Option<&Felt252>, ) -> Result { const DST_REG_MASK: i64 = 0x0001; const DST_REG_OFF: i64 = 0; @@ -212,7 +212,7 @@ mod decoder_test { // | CALL| ADD| JUMP| ADD| IMM| FP| FP // 0 0 0 1 0 1 0 0 1 0 1 0 0 1 1 1 // 0001 0100 1010 0111 = 0x14A7; offx = 0 - let inst = decode_instruction(0x14A7800080008000, Some(&Felt::new(7))).unwrap(); + let inst = decode_instruction(0x14A7800080008000, Some(&Felt252::new(7))).unwrap(); assert_matches!(inst.dst_register, Register::FP); assert_matches!(inst.op0_register, Register::FP); assert_matches!(inst.op1_addr, Op1Addr::Imm); diff --git a/src/vm/errors/hint_errors.rs b/src/vm/errors/hint_errors.rs index e2ce4ec78d..79acd0cbde 100644 --- a/src/vm/errors/hint_errors.rs +++ b/src/vm/errors/hint_errors.rs @@ -5,7 +5,7 @@ use thiserror::Error; #[cfg(all(not(feature = "std"), feature = "alloc"))] use thiserror_no_std::Error; -use felt::Felt; +use felt::Felt252; use num_bigint::{BigInt, BigUint}; use crate::types::{ @@ -40,11 +40,11 @@ pub enum HintError { #[error("Fail to get constants for hint execution")] FailedToGetConstant, #[error("Arc too big, {0} must be <= {1} and {2} <= {3}")] - ArcTooBig(Felt, Felt, Felt, Felt), + ArcTooBig(Felt252, Felt252, Felt252, Felt252), #[error("Excluded is supposed to be 2, got {0}")] - ExcludedNot2(Felt), + ExcludedNot2(Felt252), #[error("Value: {0} is outside of the range [0, 2**250)")] - ValueOutside250BitRange(Felt), + ValueOutside250BitRange(Felt252), #[error("Failed to get scope variables")] ScopeError, #[error("Variable {0} not present in current execution scope")] @@ -56,15 +56,15 @@ pub enum HintError { #[error("Dict Error: No value found for key: {0}")] NoValueForKey(MaybeRelocatable), #[error("find_element(): No value found for key: {0}")] - NoValueForKeyFindElement(Felt), + NoValueForKeyFindElement(Felt252), #[error("Assertion failed, a = {0} % PRIME is not less than b = {1} % PRIME")] - AssertLtFelt(Felt, Felt), + AssertLtFelt252(Felt252, Felt252), #[error("find_element() can only be used with n_elms <= {0}.\nGot: n_elms = {1}")] - FindElemMaxSize(Felt, Felt), + FindElemMaxSize(Felt252, Felt252), #[error( "Invalid index found in find_element_index. Index: {0}.\nExpected key: {1}, found_key {2}" )] - InvalidIndex(Felt, Felt, Felt), + InvalidIndex(Felt252, Felt252, Felt252), #[error("Found Key is None")] KeyNotFound, #[error("AP tracking data is None; could not apply correction to address")] @@ -76,7 +76,7 @@ pub enum HintError { #[error("Dict Error: Tried to create a dict whithout an initial dict")] NoInitialDict, #[error("squash_dict_inner fail: couldnt find key {0} in accesses_indices")] - NoKeyInAccessIndices(Felt), + NoKeyInAccessIndices(Felt252), #[error("squash_dict_inner fail: local accessed_indices is empty")] EmptyAccessIndices, #[error("squash_dict_inner fail: local current_accessed_indices is empty")] @@ -86,7 +86,7 @@ pub enum HintError { #[error("Dict Error: Got the wrong value for dict_update, expected value: {0}, got: {1} for key: {2}")] WrongPrevValue(MaybeRelocatable, MaybeRelocatable, MaybeRelocatable), #[error("squash_dict_inner fail: Number of used accesses:{0} doesnt match the lengh: {1} of the access_indices at key: {2}")] - NumUsedAccessesAssertFail(Felt, usize, Felt), + NumUsedAccessesAssertFail(Felt252, usize, Felt252), #[error("squash_dict_inner fail: local keys is not empty")] KeysNotEmpty, #[error("squash_dict_inner fail: No keys left but remaining_accesses > 0")] @@ -94,9 +94,9 @@ pub enum HintError { #[error("squash_dict fail: Accesses array size must be divisible by DictAccess.SIZE")] PtrDiffNotDivisibleByDictAccessSize, #[error("squash_dict() can only be used with n_accesses<={0}. ' \nGot: n_accesses={1}")] - SquashDictMaxSizeExceeded(Felt, Felt), + SquashDictMaxSizeExceeded(Felt252, Felt252), #[error("squash_dict fail: n_accesses: {0} is too big to be converted into an iterator")] - NAccessesTooBig(Felt), + NAccessesTooBig(Felt252), #[error(transparent)] Internal(#[from] VirtualMachineError), #[error(transparent)] @@ -104,7 +104,7 @@ pub enum HintError { #[error("Couldn't convert BigInt to usize")] BigintToUsizeFail, #[error("usort() can only be used with input_len<={0}. Got: input_len={1}.")] - UsortOutOfRange(u64, Felt), + UsortOutOfRange(u64, Felt252), #[error("unexpected usort fail: positions_dict or key value pair not found")] UnexpectedPositionsDictFail, #[error("unexpected verify multiplicity fail: positions not found")] @@ -130,11 +130,11 @@ pub enum HintError { #[error("verify_zero: Invalid input {0}")] SecpVerifyZero(BigInt), #[error("unsafe_keccak() can only be used with length<={0}. Got: length={1}")] - KeccakMaxSize(Felt, Felt), + KeccakMaxSize(Felt252, Felt252), #[error("Invalid word size: {0}")] - InvalidWordSize(Felt), + InvalidWordSize(Felt252), #[error("Invalid input length, Got: length={0}")] - InvalidKeccakInputLength(Felt), + InvalidKeccakInputLength(Felt252), #[error(transparent)] FromScopeError(#[from] ExecScopeError), #[error("assert_not_equal failed: {0} = {1}")] @@ -142,27 +142,27 @@ pub enum HintError { #[error("split_int(): value is out of range")] SplitIntNotZero, #[error("split_int(): Limb {0} is out of range.")] - SplitIntLimbOutOfRange(Felt), + SplitIntLimbOutOfRange(Felt252), #[error("Expected size to be in the range from [0, 100), got: {0}")] - InvalidKeccakStateSizeFelts(Felt), + InvalidKeccakStateSizeFelt252s(Felt252), #[error("Expected size to be in range from [0, 10), got: {0}")] - InvalidBlockSize(Felt), + InvalidBlockSize(Felt252), #[error("Couldn't convert BigInt to u32")] BigintToU32Fail, #[error("BigInt to BigUint failed, BigInt is negative")] BigIntToBigUintFail, #[error("Assertion failed, 0 <= ids.a % PRIME < range_check_builtin.bound \n a = {0} is out of range")] - ValueOutOfRange(Felt), + ValueOutOfRange(Felt252), #[error("Assertion failed, 0 <= ids.a % PRIME < range_check_builtin.bound \n a = {0} is out of range")] - AssertNNValueOutOfRange(Felt), + AssertNNValueOutOfRange(Felt252), #[error("Assertion failed, {0} % {1} is equal to 0")] - AssertNotZero(Felt, String), + AssertNotZero(Felt252, String), #[error("Div out of range: 0 < {0} <= {1}")] - OutOfValidRange(Felt, Felt), + OutOfValidRange(Felt252, Felt252), #[error("Value: {0} is outside valid range")] - ValueOutsideValidRange(Felt), + ValueOutsideValidRange(Felt252), #[error("Assertion failed, {0}, is not less or equal to {1}")] - NonLeFelt(Felt, Felt), + NonLeFelt252(Felt252, Felt252), #[error("Unknown Hint: {0}")] UnknownHint(String), #[error("Signature hint must point to the signature builtin segment, not {0}.")] diff --git a/src/vm/errors/memory_errors.rs b/src/vm/errors/memory_errors.rs index a6cf4eeb4f..9b2e0abb09 100644 --- a/src/vm/errors/memory_errors.rs +++ b/src/vm/errors/memory_errors.rs @@ -5,7 +5,7 @@ use thiserror::Error; #[cfg(all(not(feature = "std"), feature = "alloc"))] use thiserror_no_std::Error; -use felt::Felt; +use felt::Felt252; use crate::types::{ errors::math_errors::MathError, @@ -19,7 +19,7 @@ pub enum MemoryError { #[error("Memory addresses must be relocatable")] AddressNotRelocatable, #[error("Range-check validation failed, number {0} is out of valid range [0, {1}]")] - RangeCheckNumOutOfBounds(Felt, Felt), + RangeCheckNumOutOfBounds(Felt252, Felt252), #[error("Range-check validation failed, encountered non-int value at address {0}")] RangeCheckFoundNonInt(Relocatable), #[error("Inconsistent memory assignment at address {0:?}. {1:?} != {2:?}")] @@ -54,7 +54,7 @@ pub enum MemoryError { "Signature {0}, is invalid, with respect to the public key {1}, and the message hash {2}." )] - InvalidSignature(String, Felt, Felt), + InvalidSignature(String, Felt252, Felt252), #[error( "Signature hint is missing for ECDSA builtin at address {0}. Add it using 'ecdsa_builtin.add_signature'." diff --git a/src/vm/errors/runner_errors.rs b/src/vm/errors/runner_errors.rs index 518fe75f14..3d2b77ce70 100644 --- a/src/vm/errors/runner_errors.rs +++ b/src/vm/errors/runner_errors.rs @@ -10,7 +10,7 @@ use crate::types::{ errors::math_errors::MathError, relocatable::{MaybeRelocatable, Relocatable}, }; -use felt::Felt; +use felt::Felt252; #[derive(Debug, PartialEq, Error)] pub enum RunnerError { @@ -33,15 +33,15 @@ pub enum RunnerError { #[error("Failed to convert string to FieldElement")] FailedStringConversion, #[error("EcOpBuiltin: m should be at most {0}")] - EcOpBuiltinScalarLimit(Felt), + EcOpBuiltinScalarLimit(Felt252), #[error("Given builtins are not in appropiate order")] DisorderedBuiltins, #[error("Expected integer at address {0:?} to be smaller than 2^{1}, Got {2}")] - IntegerBiggerThanPowerOfTwo(MaybeRelocatable, u32, Felt), + IntegerBiggerThanPowerOfTwo(MaybeRelocatable, u32, Felt252), #[error("{0}")] EcOpSameXCoordinate(String), #[error("EcOpBuiltin: point {0:?} is not on the curve")] - PointNotOnCurve((Felt, Felt)), + PointNotOnCurve((Felt252, Felt252)), #[error("Builtin(s) {0:?} not present in layout {1}")] NoBuiltinForInstance(HashSet<&'static str>, String), #[error("Invalid layout {0}")] diff --git a/src/vm/errors/vm_errors.rs b/src/vm/errors/vm_errors.rs index 2ee743d006..680f5cf11a 100644 --- a/src/vm/errors/vm_errors.rs +++ b/src/vm/errors/vm_errors.rs @@ -15,7 +15,7 @@ use crate::{ runner_errors::RunnerError, trace_errors::TraceError, }, }; -use felt::Felt; +use felt::Felt252; #[derive(Debug, Error)] pub enum VirtualMachineError { @@ -74,7 +74,7 @@ pub enum VirtualMachineError { #[error("Expected ecdsa builtin to be present")] NoSignatureBuiltin, #[error("Div out of range: 0 < {0} <= {1}")] - OutOfValidRange(Felt, Felt), + OutOfValidRange(Felt252, Felt252), #[error("Failed to compare {0} and {1}, cant compare a relocatable to an integer value")] DiffTypeComparison(MaybeRelocatable, MaybeRelocatable), #[error("Failed to compare {0} and {1}, cant compare two relocatable values of different segment indexes")] diff --git a/src/vm/hooks.rs b/src/vm/hooks.rs index 883e1241ff..05b1dea773 100644 --- a/src/vm/hooks.rs +++ b/src/vm/hooks.rs @@ -11,7 +11,7 @@ use crate::stdlib::{any::Any, collections::HashMap, prelude::*, sync::Arc}; -use felt::Felt; +use felt::Felt252; use crate::{ hint_processor::hint_processor_definition::HintProcessor, types::exec_scope::ExecutionScopes, @@ -38,7 +38,7 @@ type StepHookFunc = Arc< &mut dyn HintProcessor, &mut ExecutionScopes, &HashMap>>, - &HashMap, + &HashMap, ) -> Result<(), VirtualMachineError> + Sync + Send, @@ -86,7 +86,7 @@ impl VirtualMachine { hint_executor: &mut dyn HintProcessor, exec_scope: &mut ExecutionScopes, hint_data_dictionary: &HashMap>>, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), VirtualMachineError> { if let Some(hook_func) = self.hooks.clone().pre_step_instruction { (hook_func)( @@ -106,7 +106,7 @@ impl VirtualMachine { hint_executor: &mut dyn HintProcessor, exec_scope: &mut ExecutionScopes, hint_data_dictionary: &HashMap>>, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), VirtualMachineError> { if let Some(hook_func) = self.hooks.clone().post_step_instruction { (hook_func)( @@ -171,7 +171,7 @@ mod tests { _hint_processor: &mut dyn HintProcessor, _exec_scope: &mut ExecutionScopes, _hint_data: &HashMap>>, - _constants: &HashMap, + _constants: &HashMap, ) -> Result<(), VirtualMachineError> { Err(VirtualMachineError::Unexpected) } @@ -181,7 +181,7 @@ mod tests { _hint_processor: &mut dyn HintProcessor, _exec_scope: &mut ExecutionScopes, _hint_data: &HashMap>>, - _constants: &HashMap, + _constants: &HashMap, ) -> Result<(), VirtualMachineError> { Err(VirtualMachineError::Unexpected) } @@ -241,7 +241,7 @@ mod tests { _hint_processor: &mut dyn HintProcessor, _exec_scope: &mut ExecutionScopes, _hint_data: &HashMap>>, - _constants: &HashMap, + _constants: &HashMap, ) -> Result<(), VirtualMachineError> { Ok(()) } @@ -251,7 +251,7 @@ mod tests { _hint_processor: &mut dyn HintProcessor, _exec_scope: &mut ExecutionScopes, _hint_data: &HashMap>>, - _constants: &HashMap, + _constants: &HashMap, ) -> Result<(), VirtualMachineError> { Ok(()) } diff --git a/src/vm/runners/builtin_runner/bitwise.rs b/src/vm/runners/builtin_runner/bitwise.rs index 311bfb76b8..787be08da3 100644 --- a/src/vm/runners/builtin_runner/bitwise.rs +++ b/src/vm/runners/builtin_runner/bitwise.rs @@ -239,7 +239,7 @@ mod tests { hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor, types::program::Program, utils::test_utils::*, vm::runners::cairo_runner::CairoRunner, }; - use felt::Felt; + use felt::Felt252; #[cfg(target_arch = "wasm32")] use wasm_bindgen_test::*; @@ -460,7 +460,7 @@ mod tests { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 7), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); let result = builtin.deduce_memory_cell(Relocatable::from((0, 7)), &memory); - assert_eq!(result, Ok(Some(MaybeRelocatable::from(Felt::new(8))))); + assert_eq!(result, Ok(Some(MaybeRelocatable::from(Felt252::new(8))))); } #[test] @@ -469,7 +469,7 @@ mod tests { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 8), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); let result = builtin.deduce_memory_cell(Relocatable::from((0, 8)), &memory); - assert_eq!(result, Ok(Some(MaybeRelocatable::from(Felt::new(6))))); + assert_eq!(result, Ok(Some(MaybeRelocatable::from(Felt252::new(6))))); } #[test] @@ -478,7 +478,7 @@ mod tests { let memory = memory![((0, 5), 10), ((0, 6), 12), ((0, 9), 0)]; let builtin = BitwiseBuiltinRunner::new(&BitwiseInstanceDef::default(), true); let result = builtin.deduce_memory_cell(Relocatable::from((0, 9)), &memory); - assert_eq!(result, Ok(Some(MaybeRelocatable::from(Felt::new(14))))); + assert_eq!(result, Ok(Some(MaybeRelocatable::from(Felt252::new(14))))); } #[test] diff --git a/src/vm/runners/builtin_runner/ec_op.rs b/src/vm/runners/builtin_runner/ec_op.rs index 5e7322c696..e29385325c 100644 --- a/src/vm/runners/builtin_runner/ec_op.rs +++ b/src/vm/runners/builtin_runner/ec_op.rs @@ -10,7 +10,7 @@ use crate::vm::errors::runner_errors::RunnerError; use crate::vm::vm_core::VirtualMachine; use crate::vm::vm_memory::memory::Memory; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; -use felt::Felt; +use felt::Felt252; use num_bigint::{BigInt, ToBigInt}; use num_integer::{div_ceil, Integer}; use num_traits::{Num, One, Pow, Zero}; @@ -45,7 +45,7 @@ impl EcOpBuiltinRunner { ///Returns True if the point (x, y) is on the elliptic curve defined as ///y^2 = x^3 + alpha * x + beta (mod p) ///or False otherwise. - fn point_on_curve(x: &Felt, y: &Felt, alpha: &Felt, beta: &Felt) -> bool { + fn point_on_curve(x: &Felt252, y: &Felt252, alpha: &Felt252, beta: &Felt252) -> bool { y.pow(2) == &(x.pow(3) + alpha * x) + beta } @@ -57,9 +57,9 @@ impl EcOpBuiltinRunner { /// would not yield a correct result, i.e. when any part of the computation attempts to add /// two points with the same x coordinate. fn ec_op_impl( - partial_sum: (Felt, Felt), - doubled_point: (Felt, Felt), - m: &Felt, + partial_sum: (Felt252, Felt252), + doubled_point: (Felt252, Felt252), + m: &Felt252, alpha: &BigInt, prime: &BigInt, height: u32, @@ -141,10 +141,10 @@ impl EcOpBuiltinRunner { //Constant values declared here const EC_POINT_INDICES: [(usize, usize); 3] = [(0, 1), (2, 3), (5, 6)]; const OUTPUT_INDICES: (usize, usize) = EC_POINT_INDICES[2]; - let alpha: Felt = Felt::one(); - let beta_low: Felt = Felt::new(0x609ad26c15c915c1f4cdfcb99cee9e89_u128); - let beta_high: Felt = Felt::new(0x6f21413efbe40de150e596d72f7a8c5_u128); - let beta: Felt = (beta_high << 128_usize) + beta_low; + let alpha: Felt252 = Felt252::one(); + let beta_low: Felt252 = Felt252::new(0x609ad26c15c915c1f4cdfcb99cee9e89_u128); + let beta_high: Felt252 = Felt252::new(0x6f21413efbe40de150e596d72f7a8c5_u128); + let beta: Felt252 = (beta_high << 128_usize) + beta_low; let index = address .offset @@ -156,7 +156,7 @@ impl EcOpBuiltinRunner { let instance = Relocatable::from((address.segment_index, address.offset - index)); //All input cells should be filled, and be integer values //If an input cell is not filled, return None - let mut input_cells = Vec::<&Felt>::with_capacity(self.n_input_cells as usize); + let mut input_cells = Vec::<&Felt252>::with_capacity(self.n_input_cells as usize); for i in 0..self.n_input_cells as usize { match memory.get(&(instance + i)?) { None => return Ok(None), @@ -206,8 +206,8 @@ impl EcOpBuiltinRunner { self.ec_op_builtin.scalar_height, )?; match index - self.n_input_cells as usize { - 0 => Ok(Some(MaybeRelocatable::Int(Felt::new(result.0)))), - _ => Ok(Some(MaybeRelocatable::Int(Felt::new(result.1)))), + 0 => Ok(Some(MaybeRelocatable::Int(Felt252::new(result.0)))), + _ => Ok(Some(MaybeRelocatable::Int(Felt252::new(result.1)))), //Default case corresponds to 1, as there are no other possible cases } } @@ -553,7 +553,7 @@ mod tests { let y = felt_str!( "152666792071518830868575557812948353041420400780739481342941381225525861407" ); - let alpha = Felt::one(); + let alpha = Felt252::one(); let beta = felt_str!( "3141592653589793238462643383279502884197169399375105820974944592307816406665" ); @@ -569,7 +569,7 @@ mod tests { let y = felt_str!( "2119589567875935397690285099786081818522144748339117565577200220779667999801" ); - let alpha = Felt::one(); + let alpha = Felt252::one(); let beta = felt_str!( "3141592653589793238462643383279502884197169399375105820974944592307816406665" ); @@ -585,7 +585,7 @@ mod tests { let y = felt_str!( "152666792071518830868575557812948353041420400780739481342941381225525861407" ); - let alpha = Felt::one(); + let alpha = Felt252::one(); let beta = felt_str!( "3141592653589793238462643383279502884197169399375105820974944592307816406665" ); @@ -601,7 +601,7 @@ mod tests { let y = felt_str!( "2119589567875935397690885099786081818522144748339117565577200220779667999801" ); - let alpha = Felt::one(); + let alpha = Felt252::one(); let beta = felt_str!( "3141592653589793238462643383279502884197169399375105820974944592307816406665" ); @@ -627,7 +627,7 @@ mod tests { "152666792071518830868575557812948353041420400780739481342941381225525861407" ), ); - let m = Felt::new(34); + let m = Felt252::new(34); let alpha = bigint!(1); let height = 256; let prime = (*CAIRO_PRIME).clone().into(); @@ -665,7 +665,7 @@ mod tests { "152666792071518830868575557812948353041420400780739481342941381225525861407" ), ); - let m = Felt::new(34); + let m = Felt252::new(34); let alpha = bigint!(1); let height = 256; let prime = (*CAIRO_PRIME).clone().into(); @@ -688,9 +688,9 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] #[allow(deprecated)] fn compute_ec_op_invalid_same_x_coordinate() { - let partial_sum = (Felt::one(), Felt::new(9)); - let doubled_point = (Felt::one(), Felt::new(12)); - let m = Felt::new(34); + let partial_sum = (Felt252::one(), Felt252::new(9)); + let doubled_point = (Felt252::one(), Felt252::new(12)); + let m = Felt252::new(34); let alpha = bigint!(1); let height = 256; let prime = (*CAIRO_PRIME).clone().into(); diff --git a/src/vm/runners/builtin_runner/hash.rs b/src/vm/runners/builtin_runner/hash.rs index 89a40f6086..7bb505b136 100644 --- a/src/vm/runners/builtin_runner/hash.rs +++ b/src/vm/runners/builtin_runner/hash.rs @@ -10,7 +10,7 @@ use crate::vm::errors::runner_errors::RunnerError; use crate::vm::vm_core::VirtualMachine; use crate::vm::vm_memory::memory::Memory; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; -use felt::Felt; +use felt::Felt252; use num_integer::{div_ceil, Integer}; use starknet_crypto::{pedersen_hash, FieldElement}; @@ -108,7 +108,7 @@ impl HashBuiltinRunner { let fe_result = pedersen_hash(&x, &y); //Convert result from FieldElement to MaybeRelocatable let r_byte_slice = fe_result.to_bytes_be(); - let result = Felt::from_bytes_be(&r_byte_slice); + let result = Felt252::from_bytes_be(&r_byte_slice); return Ok(Some(MaybeRelocatable::from(result))); } Ok(None) diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 4fd7939132..e8b61d066c 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -9,7 +9,7 @@ use crate::vm::errors::runner_errors::RunnerError; use crate::vm::vm_core::VirtualMachine; use crate::vm::vm_memory::memory::Memory; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; -use felt::Felt; +use felt::Felt252; use num_integer::div_ceil; use num_traits::{One, ToPrimitive}; @@ -99,7 +99,7 @@ impl KeccakBuiltinRunner { if let Some((i, bits)) = self.state_rep.iter().enumerate().next() { let val = memory.get_integer((first_input_addr + i)?)?; - if val.as_ref() >= &(Felt::one() << *bits) { + if val.as_ref() >= &(Felt252::one() << *bits) { return Err(RunnerError::IntegerBiggerThanPowerOfTwo( (first_input_addr + i)?.into(), *bits, @@ -116,7 +116,7 @@ impl KeccakBuiltinRunner { return Ok(input_felts_u64 .get(address.offset - 1) - .map(|x| Felt::from(*x).into())); + .map(|x| Felt252::from(*x).into())); } Ok(None) } @@ -549,7 +549,7 @@ mod tests { let result = builtin.deduce_memory_cell(Relocatable::from((0, 25)), &memory); assert_eq!( result, - Ok(Some(MaybeRelocatable::from(Felt::new( + Ok(Some(MaybeRelocatable::from(Felt252::new( 3086936446498698982_u64 )))) ); diff --git a/src/vm/runners/builtin_runner/range_check.rs b/src/vm/runners/builtin_runner/range_check.rs index 4d748f9d77..8f5d372e36 100644 --- a/src/vm/runners/builtin_runner/range_check.rs +++ b/src/vm/runners/builtin_runner/range_check.rs @@ -22,7 +22,7 @@ use crate::{ }, }, }; -use felt::Felt; +use felt::Felt252; use num_integer::Integer; use num_traits::{One, ToPrimitive, Zero}; @@ -36,7 +36,7 @@ pub struct RangeCheckBuiltinRunner { pub(crate) cells_per_instance: u32, pub(crate) n_input_cells: u32, inner_rc_bound: usize, - pub _bound: Option, + pub _bound: Option, pub(crate) included: bool, n_parts: u32, instances_per_component: u32, @@ -46,11 +46,11 @@ impl RangeCheckBuiltinRunner { pub fn new(ratio: u32, n_parts: u32, included: bool) -> RangeCheckBuiltinRunner { let inner_rc_bound = 1_usize << 16; - let bound = Felt::one().shl(16 * n_parts); + let bound = Felt252::one().shl(16 * n_parts); let _bound = if n_parts != 0 && bound.is_zero() { None } else { - Some(Felt::new(bound)) + Some(Felt252::new(bound)) }; RangeCheckBuiltinRunner { @@ -93,12 +93,13 @@ impl RangeCheckBuiltinRunner { let num = memory .get_integer(address) .map_err(|_| MemoryError::RangeCheckFoundNonInt(address))?; - if &Felt::zero() <= num.as_ref() && num.as_ref() < &Felt::one().shl(128_usize) { + if &Felt252::zero() <= num.as_ref() && num.as_ref() < &Felt252::one().shl(128_usize) + { Ok(vec![address.to_owned()]) } else { Err(MemoryError::RangeCheckNumOutOfBounds( num.into_owned(), - Felt::one().shl(128_usize), + Felt252::one().shl(128_usize), )) } }, @@ -167,7 +168,7 @@ impl RangeCheckBuiltinRunner { pub fn get_range_check_usage(&self, memory: &Memory) -> Option<(usize, usize)> { let mut rc_bounds: Option<(usize, usize)> = None; let range_check_segment = memory.data.get(self.base)?; - let inner_rc_bound = Felt::new(self.inner_rc_bound); + let inner_rc_bound = Felt252::new(self.inner_rc_bound); for value in range_check_segment { //Split val into n_parts parts. for _ in 0..self.n_parts { diff --git a/src/vm/runners/builtin_runner/signature.rs b/src/vm/runners/builtin_runner/signature.rs index b9c29f7c33..996c9c96e6 100644 --- a/src/vm/runners/builtin_runner/signature.rs +++ b/src/vm/runners/builtin_runner/signature.rs @@ -18,7 +18,7 @@ use crate::{ }, }, }; -use felt::Felt; +use felt::Felt252; use num_integer::div_ceil; use starknet_crypto::{verify, FieldElement, Signature}; @@ -55,7 +55,7 @@ impl SignatureBuiltinRunner { pub fn add_signature( &mut self, relocatable: Relocatable, - (r, s): &(Felt, Felt), + (r, s): &(Felt252, Felt252), ) -> Result<(), MemoryError> { let r_string = r.to_str_radix(10); let s_string = s.to_str_radix(10); diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index 86cf0eea7c..281ad74d1d 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -43,7 +43,7 @@ use crate::{ }, }, }; -use felt::Felt; +use felt::Felt252; use num_integer::div_rem; use num_traits::Zero; @@ -83,7 +83,7 @@ pub struct CairoRunner { execution_public_memory: Option>, proof_mode: bool, pub original_steps: Option, - pub relocated_memory: Vec>, + pub relocated_memory: Vec>, pub relocated_trace: Option>, pub exec_scopes: ExecutionScopes, } @@ -398,7 +398,7 @@ impl CairoRunner { .ok_or(RunnerError::NoExecBase)? + 2, ), - MaybeRelocatable::from(Felt::zero()), + MaybeRelocatable::from(Felt252::zero()), ]; stack_prefix.extend(stack); self.execution_public_memory = Some(Vec::from_iter(0..stack_prefix.len())); @@ -501,7 +501,7 @@ impl CairoRunner { Ok(hint_data_dictionary) } - pub fn get_constants(&self) -> &HashMap { + pub fn get_constants(&self) -> &HashMap { &self.program.constants } @@ -720,7 +720,7 @@ impl CairoRunner { } /// Relocates the VM's memory, turning bidimensional indexes into contiguous numbers, and values - /// into Felts. Uses the relocation_table to asign each index a number according to the value + /// into Felt252s. Uses the relocation_table to asign each index a number according to the value /// on its segment number. fn relocate_memory( &mut self, @@ -1379,8 +1379,8 @@ mod tests { offset: 0, }); let stack = vec![ - MaybeRelocatable::from(Felt::new(4_i32)), - MaybeRelocatable::from(Felt::new(6_i32)), + MaybeRelocatable::from(Felt252::new(4_i32)), + MaybeRelocatable::from(Felt252::new(6_i32)), ]; assert!(cairo_runner.initialize_state(&mut vm, 1, stack).is_err()); } @@ -1397,8 +1397,8 @@ mod tests { } cairo_runner.program_base = Some(relocatable!(1, 0)); let stack = vec![ - MaybeRelocatable::from(Felt::new(4_i32)), - MaybeRelocatable::from(Felt::new(6_i32)), + MaybeRelocatable::from(Felt252::new(4_i32)), + MaybeRelocatable::from(Felt252::new(6_i32)), ]; cairo_runner.initialize_state(&mut vm, 1, stack).unwrap(); } @@ -1416,7 +1416,7 @@ mod tests { cairo_runner.program_base = Some(relocatable!(0, 0)); cairo_runner.execution_base = Some(relocatable!(1, 0)); let stack = Vec::new(); - let return_fp = MaybeRelocatable::from(Felt::new(9_i32)); + let return_fp = MaybeRelocatable::from(Felt252::new(9_i32)); cairo_runner .initialize_function_entrypoint(&mut vm, 0, stack, return_fp) .unwrap(); @@ -1437,8 +1437,8 @@ mod tests { } cairo_runner.program_base = Some(relocatable!(0, 0)); cairo_runner.execution_base = Some(relocatable!(1, 0)); - let stack = vec![MaybeRelocatable::from(Felt::new(7_i32))]; - let return_fp = MaybeRelocatable::from(Felt::new(9_i32)); + let stack = vec![MaybeRelocatable::from(Felt252::new(7_i32))]; + let return_fp = MaybeRelocatable::from(Felt252::new(9_i32)); cairo_runner .initialize_function_entrypoint(&mut vm, 1, stack, return_fp) .unwrap(); @@ -1459,8 +1459,8 @@ mod tests { let program = program![BuiltinName::output]; let mut cairo_runner = cairo_runner!(program); let mut vm = vm!(); - let stack = vec![MaybeRelocatable::from(Felt::new(7_i32))]; - let return_fp = MaybeRelocatable::from(Felt::new(9_i32)); + let stack = vec![MaybeRelocatable::from(Felt252::new(7_i32))]; + let return_fp = MaybeRelocatable::from(Felt252::new(9_i32)); cairo_runner .initialize_function_entrypoint(&mut vm, 1, stack, return_fp) .unwrap(); @@ -2309,21 +2309,21 @@ mod tests { .memory .insert( &MaybeRelocatable::from((0, 0)), - &MaybeRelocatable::from(Felt::new(4613515612218425347_i64)), + &MaybeRelocatable::from(Felt252::new(4613515612218425347_i64)), ) .unwrap(); vm.segments .memory .insert( &MaybeRelocatable::from((0, 1)), - &MaybeRelocatable::from(Felt::new(5)), + &MaybeRelocatable::from(Felt252::new(5)), ) .unwrap(); vm.segments .memory .insert( &MaybeRelocatable::from((0, 2)), - &MaybeRelocatable::from(Felt::new(2345108766317314046_i64)), + &MaybeRelocatable::from(Felt252::new(2345108766317314046_i64)), ) .unwrap(); vm.segments @@ -2344,7 +2344,7 @@ mod tests { .memory .insert( &MaybeRelocatable::from((1, 5)), - &MaybeRelocatable::from(Felt::new(5)), + &MaybeRelocatable::from(Felt252::new(5)), ) .unwrap(); vm.segments.compute_effective_sizes(); @@ -2356,19 +2356,19 @@ mod tests { assert_eq!(cairo_runner.relocated_memory[0], None); assert_eq!( cairo_runner.relocated_memory[1], - Some(Felt::new(4613515612218425347_i64)) + Some(Felt252::new(4613515612218425347_i64)) ); - assert_eq!(cairo_runner.relocated_memory[2], Some(Felt::new(5))); + assert_eq!(cairo_runner.relocated_memory[2], Some(Felt252::new(5))); assert_eq!( cairo_runner.relocated_memory[3], - Some(Felt::new(2345108766317314046_i64)) + Some(Felt252::new(2345108766317314046_i64)) ); - assert_eq!(cairo_runner.relocated_memory[4], Some(Felt::new(10))); - assert_eq!(cairo_runner.relocated_memory[5], Some(Felt::new(10))); + assert_eq!(cairo_runner.relocated_memory[4], Some(Felt252::new(10))); + assert_eq!(cairo_runner.relocated_memory[5], Some(Felt252::new(10))); assert_eq!(cairo_runner.relocated_memory[6], None); assert_eq!(cairo_runner.relocated_memory[7], None); assert_eq!(cairo_runner.relocated_memory[8], None); - assert_eq!(cairo_runner.relocated_memory[9], Some(Felt::new(5))); + assert_eq!(cairo_runner.relocated_memory[9], Some(Felt252::new(5))); } #[test] @@ -2462,29 +2462,29 @@ mod tests { assert_eq!(cairo_runner.relocated_memory[0], None); assert_eq!( cairo_runner.relocated_memory[1], - Some(Felt::new(4612671182993129469_i64)) + Some(Felt252::new(4612671182993129469_i64)) ); assert_eq!( cairo_runner.relocated_memory[2], - Some(Felt::new(5198983563776393216_i64)) + Some(Felt252::new(5198983563776393216_i64)) ); - assert_eq!(cairo_runner.relocated_memory[3], Some(Felt::one())); + assert_eq!(cairo_runner.relocated_memory[3], Some(Felt252::one())); assert_eq!( cairo_runner.relocated_memory[4], - Some(Felt::new(2345108766317314046_i64)) + Some(Felt252::new(2345108766317314046_i64)) ); assert_eq!( cairo_runner.relocated_memory[5], - Some(Felt::new(5191102247248822272_i64)) + Some(Felt252::new(5191102247248822272_i64)) ); assert_eq!( cairo_runner.relocated_memory[6], - Some(Felt::new(5189976364521848832_i64)) + Some(Felt252::new(5189976364521848832_i64)) ); - assert_eq!(cairo_runner.relocated_memory[7], Some(Felt::one())); + assert_eq!(cairo_runner.relocated_memory[7], Some(Felt252::one())); assert_eq!( cairo_runner.relocated_memory[8], - Some(Felt::new(1226245742482522112_i64)) + Some(Felt252::new(1226245742482522112_i64)) ); assert_eq!( cairo_runner.relocated_memory[9], @@ -2494,12 +2494,12 @@ mod tests { ); assert_eq!( cairo_runner.relocated_memory[10], - Some(Felt::new(5189976364521848832_i64)) + Some(Felt252::new(5189976364521848832_i64)) ); - assert_eq!(cairo_runner.relocated_memory[11], Some(Felt::new(17))); + assert_eq!(cairo_runner.relocated_memory[11], Some(Felt252::new(17))); assert_eq!( cairo_runner.relocated_memory[12], - Some(Felt::new(1226245742482522112_i64)) + Some(Felt252::new(1226245742482522112_i64)) ); assert_eq!( cairo_runner.relocated_memory[13], @@ -2509,22 +2509,25 @@ mod tests { ); assert_eq!( cairo_runner.relocated_memory[14], - Some(Felt::new(2345108766317314046_i64)) + Some(Felt252::new(2345108766317314046_i64)) ); - assert_eq!(cairo_runner.relocated_memory[15], Some(Felt::new(27_i32))); - assert_eq!(cairo_runner.relocated_memory[16], Some(Felt::new(29))); - assert_eq!(cairo_runner.relocated_memory[17], Some(Felt::new(29))); - assert_eq!(cairo_runner.relocated_memory[18], Some(Felt::new(27))); - assert_eq!(cairo_runner.relocated_memory[19], Some(Felt::one())); - assert_eq!(cairo_runner.relocated_memory[20], Some(Felt::new(18))); - assert_eq!(cairo_runner.relocated_memory[21], Some(Felt::new(10))); - assert_eq!(cairo_runner.relocated_memory[22], Some(Felt::new(28))); - assert_eq!(cairo_runner.relocated_memory[23], Some(Felt::new(17))); - assert_eq!(cairo_runner.relocated_memory[24], Some(Felt::new(18))); - assert_eq!(cairo_runner.relocated_memory[25], Some(Felt::new(14))); - assert_eq!(cairo_runner.relocated_memory[26], Some(Felt::new(29))); - assert_eq!(cairo_runner.relocated_memory[27], Some(Felt::one())); - assert_eq!(cairo_runner.relocated_memory[28], Some(Felt::new(17))); + assert_eq!( + cairo_runner.relocated_memory[15], + Some(Felt252::new(27_i32)) + ); + assert_eq!(cairo_runner.relocated_memory[16], Some(Felt252::new(29))); + assert_eq!(cairo_runner.relocated_memory[17], Some(Felt252::new(29))); + assert_eq!(cairo_runner.relocated_memory[18], Some(Felt252::new(27))); + assert_eq!(cairo_runner.relocated_memory[19], Some(Felt252::one())); + assert_eq!(cairo_runner.relocated_memory[20], Some(Felt252::new(18))); + assert_eq!(cairo_runner.relocated_memory[21], Some(Felt252::new(10))); + assert_eq!(cairo_runner.relocated_memory[22], Some(Felt252::new(28))); + assert_eq!(cairo_runner.relocated_memory[23], Some(Felt252::new(17))); + assert_eq!(cairo_runner.relocated_memory[24], Some(Felt252::new(18))); + assert_eq!(cairo_runner.relocated_memory[25], Some(Felt252::new(14))); + assert_eq!(cairo_runner.relocated_memory[26], Some(Felt252::new(29))); + assert_eq!(cairo_runner.relocated_memory[27], Some(Felt252::one())); + assert_eq!(cairo_runner.relocated_memory[28], Some(Felt252::new(17))); } #[test] @@ -3171,8 +3174,8 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_constants() { let program_constants = HashMap::from([ - ("MAX".to_string(), Felt::new(300)), - ("MIN".to_string(), Felt::new(20)), + ("MAX".to_string(), Felt252::new(300)), + ("MIN".to_string(), Felt252::new(20)), ]); let program = program!(constants = program_constants.clone(),); let cairo_runner = cairo_runner!(program); @@ -3691,9 +3694,9 @@ mod tests { }, ]); vm.segments.memory.data = vec![vec![ - Some(MemoryCell::new(Felt::new(0x80FF_8000_0530u64).into())), - Some(MemoryCell::new(Felt::new(0xBFFF_8000_0620u64).into())), - Some(MemoryCell::new(Felt::new(0x8FFF_8000_0750u64).into())), + Some(MemoryCell::new(Felt252::new(0x80FF_8000_0530u64).into())), + Some(MemoryCell::new(Felt252::new(0xBFFF_8000_0620u64).into())), + Some(MemoryCell::new(Felt252::new(0x8FFF_8000_0750u64).into())), ]]; assert_matches!( @@ -3820,7 +3823,7 @@ mod tests { } cairo_runner.program_base = Some(relocatable!(0, 0)); cairo_runner.execution_base = Some(relocatable!(1, 0)); - let return_fp = Felt::new(9_i32).into(); + let return_fp = Felt252::new(9_i32).into(); cairo_runner .initialize_function_entrypoint(&mut vm, 0, vec![], return_fp) .unwrap(); diff --git a/src/vm/security.rs b/src/vm/security.rs index 1e1b3cb9e7..1032751fd6 100644 --- a/src/vm/security.rs +++ b/src/vm/security.rs @@ -92,7 +92,7 @@ mod test { use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{relocatable, types::program::Program, utils::test_utils::*}; use assert_matches::assert_matches; - use felt::Felt; + use felt::Felt252; use num_traits::Zero; #[cfg(target_arch = "wasm32")] @@ -187,10 +187,10 @@ mod test { fn verify_secure_runner_success() { let program = program!( data = vec![ - Felt::zero().into(), - Felt::zero().into(), - Felt::zero().into(), - Felt::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), ], main = Some(0), ); @@ -215,10 +215,10 @@ mod test { fn verify_secure_runner_temporary_memory_properly_relocated() { let program = program!( data = vec![ - Felt::zero().into(), - Felt::zero().into(), - Felt::zero().into(), - Felt::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), ], main = Some(0), ); @@ -243,10 +243,10 @@ mod test { fn verify_secure_runner_temporary_memory_not_fully_relocated() { let program = program!( data = vec![ - Felt::zero().into(), - Felt::zero().into(), - Felt::zero().into(), - Felt::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), + Felt252::zero().into(), ], main = Some(0), ); diff --git a/src/vm/vm_core.rs b/src/vm/vm_core.rs index 72daf227bd..791b863a7b 100644 --- a/src/vm/vm_core.rs +++ b/src/vm/vm_core.rs @@ -24,7 +24,7 @@ use crate::{ }, }; -use felt::Felt; +use felt::Felt252; use num_traits::{ToPrimitive, Zero}; use super::runners::builtin_runner::{ @@ -141,7 +141,7 @@ impl VirtualMachine { ///Returns the encoded instruction (the value at pc) and the immediate value (the value at pc + 1, if it exists in the memory). fn get_instruction_encoding( &self, - ) -> Result<(Cow, Option>), VirtualMachineError> { + ) -> Result<(Cow, Option>), VirtualMachineError> { let encoding_ref = match self.segments.memory.get(&self.run_context.pc) { Some(Cow::Owned(MaybeRelocatable::Int(encoding))) => Cow::Owned(encoding), Some(Cow::Borrowed(MaybeRelocatable::Int(encoding))) => Cow::Borrowed(encoding), @@ -163,7 +163,7 @@ impl VirtualMachine { MaybeRelocatable::RelocatableValue(ref rel) => rel.offset, MaybeRelocatable::Int(ref num) => num .to_usize() - .ok_or_else(|| MathError::FeltToUsizeConversion(num.clone()))?, + .ok_or_else(|| MathError::Felt252ToUsizeConversion(num.clone()))?, }, FpUpdate::Regular => return Ok(()), }; @@ -465,7 +465,7 @@ impl VirtualMachine { hint_executor: &mut dyn HintProcessor, exec_scopes: &mut ExecutionScopes, hint_data_dictionary: &HashMap>>, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), VirtualMachineError> { if let Some(hint_list) = hint_data_dictionary.get(&self.run_context.pc.offset) { for (hint_index, hint_data) in hint_list.iter().enumerate() { @@ -493,7 +493,7 @@ impl VirtualMachine { hint_executor: &mut dyn HintProcessor, exec_scopes: &mut ExecutionScopes, hint_data_dictionary: &HashMap>>, - constants: &HashMap, + constants: &HashMap, ) -> Result<(), VirtualMachineError> { self.step_hint(hint_executor, exec_scopes, hint_data_dictionary, constants)?; @@ -790,7 +790,7 @@ impl VirtualMachine { } ///Gets the integer value corresponding to the Relocatable address - pub fn get_integer(&self, key: Relocatable) -> Result, MemoryError> { + pub fn get_integer(&self, key: Relocatable) -> Result, MemoryError> { self.segments.memory.get_integer(key) } @@ -870,7 +870,7 @@ impl VirtualMachine { &self, addr: Relocatable, size: usize, - ) -> Result>, MemoryError> { + ) -> Result>, MemoryError> { self.segments.memory.get_integer_range(addr, size) } @@ -1126,7 +1126,7 @@ mod tests { fn get_instruction_encoding_successful_without_imm() { let mut vm = vm!(); vm.segments = segments![((0, 0), 5)]; - assert_eq!((Felt::new(5), None), { + assert_eq!((Felt252::new(5), None), { let value = vm.get_instruction_encoding().unwrap(); (value.0.into_owned(), value.1) }); @@ -1142,10 +1142,10 @@ mod tests { let (num, imm) = vm .get_instruction_encoding() .expect("Unexpected error on get_instruction_encoding"); - assert_eq!(num.as_ref(), &Felt::new(5)); + assert_eq!(num.as_ref(), &Felt252::new(5)); assert_eq!( imm.map(Cow::into_owned), - Some(MaybeRelocatable::Int(Felt::new(6))) + Some(MaybeRelocatable::Int(Felt252::new(6))) ); } @@ -1178,10 +1178,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1246,10 +1246,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1280,10 +1280,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1315,10 +1315,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = VirtualMachine::new(false); @@ -1352,10 +1352,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), + dst: MaybeRelocatable::Int(Felt252::new(11)), res: None, - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1388,10 +1388,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1425,10 +1425,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1462,10 +1462,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1499,10 +1499,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1521,7 +1521,7 @@ mod tests { off0: 1, off1: 2, off2: 3, - imm: Some(Felt::new(5)), + imm: Some(Felt252::new(5)), dst_register: Register::FP, op0_register: Register::AP, op1_addr: Op1Addr::AP, @@ -1533,10 +1533,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1569,8 +1569,8 @@ mod tests { let operands = Operands { dst: mayberelocatable!(1, 11), res: Some(mayberelocatable!(0, 8)), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1601,10 +1601,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), + dst: MaybeRelocatable::Int(Felt252::new(11)), res: None, - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1637,10 +1637,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1672,10 +1672,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), + dst: MaybeRelocatable::Int(Felt252::new(11)), res: None, - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1705,10 +1705,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), + dst: MaybeRelocatable::Int(Felt252::new(11)), res: Some(MaybeRelocatable::from((1, 4))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1737,10 +1737,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(0)), - res: Some(MaybeRelocatable::Int(Felt::new(0))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(0)), + res: Some(MaybeRelocatable::Int(Felt252::new(0))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1771,10 +1771,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1805,10 +1805,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + dst: MaybeRelocatable::Int(Felt252::new(11)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1845,9 +1845,9 @@ mod tests { let operands = Operands { dst: MaybeRelocatable::from((1, 11)), - res: Some(MaybeRelocatable::Int(Felt::new(8))), - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + res: Some(MaybeRelocatable::Int(Felt252::new(8))), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let mut vm = vm!(); @@ -1865,7 +1865,7 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn is_zero_int_value() { - let value = MaybeRelocatable::Int(Felt::new(1)); + let value = MaybeRelocatable::Int(Felt252::new(1)); assert!(!VirtualMachine::is_zero(&value)); } @@ -1925,16 +1925,16 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(3)); - let op1 = MaybeRelocatable::Int(Felt::new(2)); + let dst = MaybeRelocatable::Int(Felt252::new(3)); + let op1 = MaybeRelocatable::Int(Felt252::new(2)); assert_matches!( vm.deduce_op0(&instruction, Some(&dst), Some(&op1)), Ok::<(Option, Option), VirtualMachineError>(( x, y - )) if x == Some(MaybeRelocatable::Int(Felt::new(1))) && - y == Some(MaybeRelocatable::Int(Felt::new(3))) + )) if x == Some(MaybeRelocatable::Int(Felt252::new(1))) && + y == Some(MaybeRelocatable::Int(Felt252::new(3))) ); } @@ -1986,16 +1986,16 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(4)); - let op1 = MaybeRelocatable::Int(Felt::new(2)); + let dst = MaybeRelocatable::Int(Felt252::new(4)); + let op1 = MaybeRelocatable::Int(Felt252::new(2)); assert_matches!( vm.deduce_op0(&instruction, Some(&dst), Some(&op1)), Ok::<(Option, Option), VirtualMachineError>(( Some(x), Some(y) - )) if x == MaybeRelocatable::Int(Felt::new(2)) && - y == MaybeRelocatable::Int(Felt::new(4)) + )) if x == MaybeRelocatable::Int(Felt252::new(2)) && + y == MaybeRelocatable::Int(Felt252::new(4)) ); } @@ -2019,8 +2019,8 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(4)); - let op1 = MaybeRelocatable::Int(Felt::new(0)); + let dst = MaybeRelocatable::Int(Felt252::new(4)); + let op1 = MaybeRelocatable::Int(Felt252::new(0)); assert_matches!( vm.deduce_op0(&instruction, Some(&dst), Some(&op1)), Ok::<(Option, Option), VirtualMachineError>(( @@ -2049,8 +2049,8 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(4)); - let op1 = MaybeRelocatable::Int(Felt::new(0)); + let dst = MaybeRelocatable::Int(Felt252::new(4)); + let op1 = MaybeRelocatable::Int(Felt252::new(0)); assert_matches!( vm.deduce_op0(&instruction, Some(&dst), Some(&op1)), Ok::<(Option, Option), VirtualMachineError>(( @@ -2079,8 +2079,8 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(4)); - let op1 = MaybeRelocatable::Int(Felt::new(0)); + let dst = MaybeRelocatable::Int(Felt252::new(4)); + let op1 = MaybeRelocatable::Int(Felt252::new(0)); assert_matches!( vm.deduce_op0(&instruction, Some(&dst), Some(&op1)), @@ -2138,15 +2138,15 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(3)); - let op0 = MaybeRelocatable::Int(Felt::new(2)); + let dst = MaybeRelocatable::Int(Felt252::new(3)); + let op0 = MaybeRelocatable::Int(Felt252::new(2)); assert_matches!( vm.deduce_op1(&instruction, Some(&dst), Some(op0)), Ok::<(Option, Option), VirtualMachineError>(( x, y - )) if x == Some(MaybeRelocatable::Int(Felt::new(1))) && - y == Some(MaybeRelocatable::Int(Felt::new(3))) + )) if x == Some(MaybeRelocatable::Int(Felt252::new(1))) && + y == Some(MaybeRelocatable::Int(Felt252::new(3))) ); } @@ -2197,15 +2197,15 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(4)); - let op0 = MaybeRelocatable::Int(Felt::new(2)); + let dst = MaybeRelocatable::Int(Felt252::new(4)); + let op0 = MaybeRelocatable::Int(Felt252::new(2)); assert_matches!( vm.deduce_op1(&instruction, Some(&dst), Some(op0)), Ok::<(Option, Option), VirtualMachineError>(( x, y - )) if x == Some(MaybeRelocatable::Int(Felt::new(2))) && - y == Some(MaybeRelocatable::Int(Felt::new(4))) + )) if x == Some(MaybeRelocatable::Int(Felt252::new(2))) && + y == Some(MaybeRelocatable::Int(Felt252::new(4))) ); } @@ -2229,8 +2229,8 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(4)); - let op0 = MaybeRelocatable::Int(Felt::new(0)); + let dst = MaybeRelocatable::Int(Felt252::new(4)); + let op0 = MaybeRelocatable::Int(Felt252::new(0)); assert_matches!( vm.deduce_op1(&instruction, Some(&dst), Some(op0)), Ok::<(Option, Option), VirtualMachineError>(( @@ -2259,7 +2259,7 @@ mod tests { let vm = vm!(); - let op0 = MaybeRelocatable::Int(Felt::new(0)); + let op0 = MaybeRelocatable::Int(Felt252::new(0)); assert_matches!( vm.deduce_op1(&instruction, None, Some(op0)), Ok::<(Option, Option), VirtualMachineError>(( @@ -2288,14 +2288,14 @@ mod tests { let vm = vm!(); - let dst = MaybeRelocatable::Int(Felt::new(7)); + let dst = MaybeRelocatable::Int(Felt252::new(7)); assert_matches!( vm.deduce_op1(&instruction, Some(&dst), None), Ok::<(Option, Option), VirtualMachineError>(( x, y - )) if x == Some(MaybeRelocatable::Int(Felt::new(7))) && - y == Some(MaybeRelocatable::Int(Felt::new(7))) + )) if x == Some(MaybeRelocatable::Int(Felt252::new(7))) && + y == Some(MaybeRelocatable::Int(Felt252::new(7))) ); } @@ -2319,13 +2319,13 @@ mod tests { let vm = vm!(); - let op1 = MaybeRelocatable::Int(Felt::new(7)); - let op0 = MaybeRelocatable::Int(Felt::new(9)); + let op1 = MaybeRelocatable::Int(Felt252::new(7)); + let op0 = MaybeRelocatable::Int(Felt252::new(9)); assert_matches!( vm.compute_res(&instruction, &op0, &op1), Ok::, VirtualMachineError>(Some(MaybeRelocatable::Int( x - ))) if x == Felt::new(7) + ))) if x == Felt252::new(7) ); } @@ -2349,13 +2349,13 @@ mod tests { let vm = vm!(); - let op1 = MaybeRelocatable::Int(Felt::new(7)); - let op0 = MaybeRelocatable::Int(Felt::new(9)); + let op1 = MaybeRelocatable::Int(Felt252::new(7)); + let op0 = MaybeRelocatable::Int(Felt252::new(9)); assert_matches!( vm.compute_res(&instruction, &op0, &op1), Ok::, VirtualMachineError>(Some(MaybeRelocatable::Int( x - ))) if x == Felt::new(16) + ))) if x == Felt252::new(16) ); } @@ -2379,13 +2379,13 @@ mod tests { let vm = vm!(); - let op1 = MaybeRelocatable::Int(Felt::new(7)); - let op0 = MaybeRelocatable::Int(Felt::new(9)); + let op1 = MaybeRelocatable::Int(Felt252::new(7)); + let op0 = MaybeRelocatable::Int(Felt252::new(9)); assert_matches!( vm.compute_res(&instruction, &op0, &op1), Ok::, VirtualMachineError>(Some(MaybeRelocatable::Int( x - ))) if x == Felt::new(63) + ))) if x == Felt252::new(63) ); } @@ -2437,8 +2437,8 @@ mod tests { let vm = vm!(); - let op1 = MaybeRelocatable::Int(Felt::new(7)); - let op0 = MaybeRelocatable::Int(Felt::new(9)); + let op1 = MaybeRelocatable::Int(Felt252::new(7)); + let op0 = MaybeRelocatable::Int(Felt252::new(9)); assert_matches!( vm.compute_res(&instruction, &op0, &op1), Ok::, VirtualMachineError>(None) @@ -2465,9 +2465,9 @@ mod tests { let vm = vm!(); - let res = MaybeRelocatable::Int(Felt::new(7)); + let res = MaybeRelocatable::Int(Felt252::new(7)); assert_eq!( - Some(MaybeRelocatable::Int(Felt::new(7))), + Some(MaybeRelocatable::Int(Felt252::new(7))), vm.deduce_dst(&instruction, Some(&res)) ); } @@ -2569,11 +2569,11 @@ mod tests { vm.segments.memory.data.push(Vec::new()); let dst_addr = MaybeRelocatable::from((1, 0)); - let dst_addr_value = MaybeRelocatable::Int(Felt::new(5)); + let dst_addr_value = MaybeRelocatable::Int(Felt252::new(5)); let op0_addr = MaybeRelocatable::from((1, 1)); - let op0_addr_value = MaybeRelocatable::Int(Felt::new(2)); + let op0_addr_value = MaybeRelocatable::Int(Felt252::new(2)); let op1_addr = MaybeRelocatable::from((1, 2)); - let op1_addr_value = MaybeRelocatable::Int(Felt::new(3)); + let op1_addr_value = MaybeRelocatable::Int(Felt252::new(3)); vm.segments .memory .insert(&dst_addr, &dst_addr_value) @@ -2672,7 +2672,7 @@ mod tests { off0: 1, off1: 1, off2: 1, - imm: Some(Felt::new(4)), + imm: Some(Felt252::new(4)), dst_register: Register::AP, op0_register: Register::AP, op1_addr: Op1Addr::Imm, @@ -2764,10 +2764,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(8)), + dst: MaybeRelocatable::Int(Felt252::new(8)), res: None, - op0: MaybeRelocatable::Int(Felt::new(9)), - op1: MaybeRelocatable::Int(Felt::new(10)), + op0: MaybeRelocatable::Int(Felt252::new(9)), + op1: MaybeRelocatable::Int(Felt252::new(10)), }; let vm = vm!(); @@ -2795,10 +2795,10 @@ mod tests { }; let operands = Operands { - dst: MaybeRelocatable::Int(Felt::new(9_i32)), - res: Some(MaybeRelocatable::Int(Felt::new(8_i32))), - op0: MaybeRelocatable::Int(Felt::new(9_i32)), - op1: MaybeRelocatable::Int(Felt::new(10_i32)), + dst: MaybeRelocatable::Int(Felt252::new(9_i32)), + res: Some(MaybeRelocatable::Int(Felt252::new(8_i32))), + op0: MaybeRelocatable::Int(Felt252::new(9_i32)), + op1: MaybeRelocatable::Int(Felt252::new(10_i32)), }; let vm = vm!(); @@ -2808,8 +2808,8 @@ mod tests { Err(VirtualMachineError::DiffAssertValues( i, j - )) if i == MaybeRelocatable::Int(Felt::new(9_i32)) && - j == MaybeRelocatable::Int(Felt::new(8_i32)) + )) if i == MaybeRelocatable::Int(Felt252::new(9_i32)) && + j == MaybeRelocatable::Int(Felt252::new(8_i32)) ); } @@ -2834,8 +2834,8 @@ mod tests { let operands = Operands { dst: MaybeRelocatable::from((1, 1)), res: Some(MaybeRelocatable::from((1, 2))), - op0: MaybeRelocatable::Int(Felt::new(9_i32)), - op1: MaybeRelocatable::Int(Felt::new(10_i32)), + op0: MaybeRelocatable::Int(Felt252::new(9_i32)), + op1: MaybeRelocatable::Int(Felt252::new(10_i32)), }; let vm = vm!(); @@ -3155,7 +3155,7 @@ mod tests { .get(&vm.run_context.get_ap()) .unwrap() .as_ref(), - &MaybeRelocatable::Int(Felt::new(0x4)), + &MaybeRelocatable::Int(Felt252::new(0x4)), ); let mut hint_processor = BuiltinHintProcessor::new_empty(); assert_matches!( @@ -3176,7 +3176,7 @@ mod tests { .get(&vm.run_context.get_ap()) .unwrap() .as_ref(), - &MaybeRelocatable::Int(Felt::new(0x5)) + &MaybeRelocatable::Int(Felt252::new(0x5)) ); let mut hint_processor = BuiltinHintProcessor::new_empty(); @@ -3198,7 +3198,7 @@ mod tests { .get(&vm.run_context.get_ap()) .unwrap() .as_ref(), - &MaybeRelocatable::Int(Felt::new(0x14)), + &MaybeRelocatable::Int(Felt252::new(0x14)), ); } @@ -3321,7 +3321,7 @@ mod tests { vm.segments = segments![((0, 5), 10), ((0, 6), 12), ((0, 7), 0)]; assert_matches!( vm.deduce_memory_cell(Relocatable::from((0, 7))), - Ok(i) if i == Some(MaybeRelocatable::from(Felt::new(8_i32))) + Ok(i) if i == Some(MaybeRelocatable::from(Felt252::new(8_i32))) ); } @@ -3378,10 +3378,10 @@ mod tests { ]; let expected_operands = Operands { - dst: MaybeRelocatable::from(Felt::new(8_i32)), - res: Some(MaybeRelocatable::from(Felt::new(8_i32))), + dst: MaybeRelocatable::from(Felt252::new(8_i32)), + res: Some(MaybeRelocatable::from(Felt252::new(8_i32))), op0: MaybeRelocatable::from((2, 0)), - op1: MaybeRelocatable::from(Felt::new(8_i32)), + op1: MaybeRelocatable::from(Felt252::new(8_i32)), }; let expected_operands_mem_addresses = OperandsAddresses { dst_addr: Relocatable::from((1, 9)), @@ -3672,10 +3672,10 @@ mod tests { vm.set_ap(4); vm.segments = segments![((1, 0), 1), ((1, 1), 2), ((1, 2), 3), ((1, 3), 4)]; let expected = vec![ - MaybeRelocatable::Int(Felt::new(1_i32)), - MaybeRelocatable::Int(Felt::new(2_i32)), - MaybeRelocatable::Int(Felt::new(3_i32)), - MaybeRelocatable::Int(Felt::new(4_i32)), + MaybeRelocatable::Int(Felt252::new(1_i32)), + MaybeRelocatable::Int(Felt252::new(2_i32)), + MaybeRelocatable::Int(Felt252::new(3_i32)), + MaybeRelocatable::Int(Felt252::new(4_i32)), ]; assert_eq!(vm.get_return_values(4).unwrap(), expected); } @@ -3820,9 +3820,9 @@ mod tests { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; - let value1 = MaybeRelocatable::from(Felt::new(2_i32)); - let value2 = MaybeRelocatable::from(Felt::new(3_i32)); - let value3 = MaybeRelocatable::from(Felt::new(4_i32)); + let value1 = MaybeRelocatable::from(Felt252::new(2_i32)); + let value2 = MaybeRelocatable::from(Felt252::new(3_i32)); + let value3 = MaybeRelocatable::from(Felt252::new(4_i32)); let expected_vec = vec![ Some(Cow::Borrowed(&value1)), @@ -3838,9 +3838,9 @@ mod tests { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; - let value1 = MaybeRelocatable::from(Felt::new(2_i32)); - let value2 = MaybeRelocatable::from(Felt::new(3_i32)); - let value3 = MaybeRelocatable::from(Felt::new(4_i32)); + let value1 = MaybeRelocatable::from(Felt252::new(2_i32)); + let value2 = MaybeRelocatable::from(Felt252::new(3_i32)); + let value3 = MaybeRelocatable::from(Felt252::new(4_i32)); let expected_vec = vec![ Some(Cow::Borrowed(&value1)), @@ -3857,9 +3857,9 @@ mod tests { let mut vm = vm!(); vm.segments = segments![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; - let value1 = MaybeRelocatable::from(Felt::new(2_i32)); - let value2 = MaybeRelocatable::from(Felt::new(3_i32)); - let value3 = MaybeRelocatable::from(Felt::new(4_i32)); + let value1 = MaybeRelocatable::from(Felt252::new(2_i32)); + let value2 = MaybeRelocatable::from(Felt252::new(3_i32)); + let value3 = MaybeRelocatable::from(Felt252::new(4_i32)); let expected_vec = vec![value1, value2, value3]; assert_eq!( @@ -3952,7 +3952,10 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_maybe_error() { let vm = vm!(); - assert_eq!(vm.get_maybe(&MaybeRelocatable::Int(Felt::new(0_i32))), None,); + assert_eq!( + vm.get_maybe(&MaybeRelocatable::Int(Felt252::new(0_i32))), + None, + ); } #[test] diff --git a/src/vm/vm_memory/memory.rs b/src/vm/vm_memory/memory.rs index da80a04cc2..f9400e0e0e 100644 --- a/src/vm/vm_memory/memory.rs +++ b/src/vm/vm_memory/memory.rs @@ -10,7 +10,7 @@ use crate::{ utils::from_relocatable_to_indexes, vm::errors::memory_errors::MemoryError, }; -use felt::Felt; +use felt::Felt252; use num_traits::ToPrimitive; pub struct ValidationRule( @@ -215,9 +215,9 @@ impl Memory { Ok(()) } - /// Gets the value from memory address as a Felt value. - /// Returns an Error if the value at the memory address is missing or not a Felt. - pub fn get_integer(&self, key: Relocatable) -> Result, MemoryError> { + /// Gets the value from memory address as a Felt252 value. + /// Returns an Error if the value at the memory address is missing or not a Felt252. + pub fn get_integer(&self, key: Relocatable) -> Result, MemoryError> { match self.get(&key).ok_or(MemoryError::UnknownMemoryCell(key))? { Cow::Borrowed(MaybeRelocatable::Int(int)) => Ok(Cow::Borrowed(int)), Cow::Owned(MaybeRelocatable::Int(int)) => Ok(Cow::Owned(int)), @@ -308,14 +308,14 @@ impl Memory { Ok(values) } - /// Gets a range of Felt memory values from addr to addr + size + /// Gets a range of Felt252 memory values from addr to addr + size /// Fails if there if any of the values inside the range is missing (memory gap), - /// or is not a Felt + /// or is not a Felt252 pub fn get_integer_range( &self, addr: Relocatable, size: usize, - ) -> Result>, MemoryError> { + ) -> Result>, MemoryError> { let mut values = Vec::new(); for i in 0..size { @@ -402,8 +402,8 @@ impl RelocateValue<'_, Relocatable, Relocatable> for Memory { } } -impl<'a> RelocateValue<'a, &'a Felt, &'a Felt> for Memory { - fn relocate_value(&self, value: &'a Felt) -> &'a Felt { +impl<'a> RelocateValue<'a, &'a Felt252, &'a Felt252> for Memory { + fn relocate_value(&self, value: &'a Felt252) -> &'a Felt252 { value } } @@ -469,13 +469,13 @@ mod memory_tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_succesful() { let key = MaybeRelocatable::from((0, 0)); - let val = MaybeRelocatable::from(Felt::new(5)); + let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); memory.data.push(Vec::new()); memory.insert(&key, &val).unwrap(); assert_eq!( memory.get(&key).unwrap().as_ref(), - &MaybeRelocatable::from(Felt::new(5)) + &MaybeRelocatable::from(Felt252::new(5)) ); } @@ -498,13 +498,13 @@ mod memory_tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_value_in_temp_segment() { let key = MaybeRelocatable::from((-1, 3)); - let val = MaybeRelocatable::from(Felt::new(8)); + let val = MaybeRelocatable::from(Felt252::new(8)); let mut memory = Memory::new(); memory.temp_data.push(Vec::new()); memory.insert(&key, &val).unwrap(); assert_eq!( memory.temp_data[0][3], - Some(MemoryCell::new(MaybeRelocatable::from(Felt::new(8)))) + Some(MemoryCell::new(MaybeRelocatable::from(Felt252::new(8)))) ); } @@ -512,13 +512,13 @@ mod memory_tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_succesful() { let key = MaybeRelocatable::from((-1, 0)); - let val = MaybeRelocatable::from(Felt::new(5)); + let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); memory.temp_data.push(Vec::new()); memory.insert(&key, &val).unwrap(); assert_eq!( memory.get(&key).unwrap().as_ref(), - &MaybeRelocatable::from(Felt::new(5)), + &MaybeRelocatable::from(Felt252::new(5)), ); } @@ -557,7 +557,7 @@ mod memory_tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_relocatable_key() { - let key = MaybeRelocatable::from(Felt::new(0)); + let key = MaybeRelocatable::from(Felt252::new(0)); let memory = Memory::new(); assert!(memory.get(&key).is_none()); } @@ -566,7 +566,7 @@ mod memory_tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_allocated_memory() { let key = MaybeRelocatable::from((0, 0)); - let val = MaybeRelocatable::from(Felt::new(5)); + let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); let error = memory.insert(&key, &val); assert_eq!(error, Err(MemoryError::UnallocatedSegment(0, 0))); @@ -576,8 +576,8 @@ mod memory_tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_inconsistent_memory() { let key = MaybeRelocatable::from((0, 0)); - let val_a = MaybeRelocatable::from(Felt::new(5)); - let val_b = MaybeRelocatable::from(Felt::new(6)); + let val_a = MaybeRelocatable::from(Felt252::new(5)); + let val_b = MaybeRelocatable::from(Felt252::new(6)); let mut memory = Memory::new(); memory.data.push(Vec::new()); memory @@ -593,8 +593,8 @@ mod memory_tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_address_not_relocatable() { - let key = MaybeRelocatable::from(Felt::new(5)); - let val = MaybeRelocatable::from(Felt::new(5)); + let key = MaybeRelocatable::from(Felt252::new(5)); + let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); let error = memory.insert(&key, &val); assert_eq!(error, Err(MemoryError::AddressNotRelocatable)); @@ -609,7 +609,7 @@ mod memory_tests { fn insert_non_contiguous_element() { let key_a = MaybeRelocatable::from((0, 0)); let key_b = MaybeRelocatable::from((0, 2)); - let val = MaybeRelocatable::from(Felt::new(5)); + let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); memory.data.push(Vec::new()); memory.insert(&key_a, &val).unwrap(); @@ -622,7 +622,7 @@ mod memory_tests { fn insert_non_contiguous_element_memory_gaps_none() { let key_a = MaybeRelocatable::from((0, 0)); let key_b = MaybeRelocatable::from((0, 5)); - let val = MaybeRelocatable::from(Felt::new(5)); + let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); memory.data.push(Vec::new()); memory.insert(&key_a, &val).unwrap(); @@ -640,12 +640,12 @@ mod memory_tests { let mem = memory_from( vec![( MaybeRelocatable::from((1, 0)), - MaybeRelocatable::from(Felt::new(5)), + MaybeRelocatable::from(Felt252::new(5)), )], 2, ) .unwrap(); - assert_matches!(mem.get(&MaybeRelocatable::from((1, 0))), Some(inner) if inner.clone().into_owned() == MaybeRelocatable::Int(Felt::new(5))); + assert_matches!(mem.get(&MaybeRelocatable::from((1, 0))), Some(inner) if inner.clone().into_owned() == MaybeRelocatable::Int(Felt252::new(5))); } #[test] @@ -663,7 +663,7 @@ mod memory_tests { .memory .insert( &MaybeRelocatable::from((0, 0)), - &MaybeRelocatable::from(Felt::new(45)), + &MaybeRelocatable::from(Felt252::new(45)), ) .unwrap(); segments.memory.validate_existing_memory().unwrap(); @@ -684,7 +684,7 @@ mod memory_tests { .memory .insert( &MaybeRelocatable::from((1, 0)), - &MaybeRelocatable::from(Felt::new(-10)), + &MaybeRelocatable::from(Felt252::new(-10)), ) .unwrap(); builtin.add_validation_rule(&mut segments.memory); @@ -692,8 +692,8 @@ mod memory_tests { assert_eq!( error, Err(MemoryError::RangeCheckNumOutOfBounds( - Felt::new(-10), - Felt::one().shl(128_u32) + Felt252::new(-10), + Felt252::one().shl(128_u32) )) ); } @@ -790,7 +790,7 @@ mod memory_tests { .memory .insert( &MaybeRelocatable::from((0, 0)), - &MaybeRelocatable::from(Felt::new(-45)), + &MaybeRelocatable::from(Felt252::new(-45)), ) .unwrap(); builtin.add_validation_rule(&mut segments.memory); @@ -806,7 +806,7 @@ mod memory_tests { .get_integer(Relocatable::from((0, 0))) .unwrap() .as_ref(), - &Felt::new(10) + &Felt252::new(10) ); } @@ -844,7 +844,7 @@ mod memory_tests { memory.temp_data.push(Vec::new()); let key = MaybeRelocatable::from((-1, 0)); - let val = MaybeRelocatable::from(Felt::new(5)); + let val = MaybeRelocatable::from(Felt252::new(5)); memory.insert(&key, &val).unwrap(); assert_eq!(memory.get(&key).unwrap().as_ref(), &val); @@ -890,8 +890,8 @@ mod memory_tests { // Test when value is Some(BigInt): assert_eq!( - memory.relocate_value(&MaybeRelocatable::Int(Felt::new(0))), - Cow::Owned(MaybeRelocatable::Int(Felt::new(0))), + memory.relocate_value(&MaybeRelocatable::Int(Felt252::new(0))), + Cow::Owned(MaybeRelocatable::Int(Felt252::new(0))), ); } @@ -972,9 +972,9 @@ mod memory_tests { fn get_range_for_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; - let value1 = MaybeRelocatable::from(Felt::new(2)); - let value2 = MaybeRelocatable::from(Felt::new(3)); - let value3 = MaybeRelocatable::from(Felt::new(4)); + let value1 = MaybeRelocatable::from(Felt252::new(2)); + let value2 = MaybeRelocatable::from(Felt252::new(3)); + let value3 = MaybeRelocatable::from(Felt252::new(4)); let expected_vec = vec![ Some(Cow::Borrowed(&value1)), @@ -989,9 +989,9 @@ mod memory_tests { fn get_range_for_non_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 3), 4)]; - let value1 = MaybeRelocatable::from(Felt::new(2)); - let value2 = MaybeRelocatable::from(Felt::new(3)); - let value3 = MaybeRelocatable::from(Felt::new(4)); + let value1 = MaybeRelocatable::from(Felt252::new(2)); + let value2 = MaybeRelocatable::from(Felt252::new(3)); + let value3 = MaybeRelocatable::from(Felt252::new(4)); let expected_vec = vec![ Some(Cow::Borrowed(&value1)), @@ -1007,9 +1007,9 @@ mod memory_tests { fn get_continuous_range_for_continuous_memory() { let memory = memory![((1, 0), 2), ((1, 1), 3), ((1, 2), 4)]; - let value1 = MaybeRelocatable::from(Felt::new(2)); - let value2 = MaybeRelocatable::from(Felt::new(3)); - let value3 = MaybeRelocatable::from(Felt::new(4)); + let value1 = MaybeRelocatable::from(Felt252::new(2)); + let value2 = MaybeRelocatable::from(Felt252::new(3)); + let value3 = MaybeRelocatable::from(Felt252::new(4)); let expected_vec = vec![value1, value2, value3]; assert_eq!( diff --git a/src/vm/vm_memory/memory_segments.rs b/src/vm/vm_memory/memory_segments.rs index 6bef9c4673..2289aab467 100644 --- a/src/vm/vm_memory/memory_segments.rs +++ b/src/vm/vm_memory/memory_segments.rs @@ -238,7 +238,7 @@ mod tests { use super::*; use crate::{relocatable, utils::test_utils::*, vm::vm_memory::memory::MemoryCell}; use assert_matches::assert_matches; - use felt::Felt; + use felt::Felt252; use num_traits::Num; #[cfg(target_arch = "wasm32")] @@ -307,7 +307,7 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_one_element() { - let data = vec![MaybeRelocatable::from(Felt::new(4))]; + let data = vec![MaybeRelocatable::from(Felt252::new(4))]; let ptr = Relocatable::from((0, 0)); let mut segments = MemorySegmentManager::new(); segments.add(); @@ -315,7 +315,7 @@ mod tests { assert_eq!(current_ptr, Relocatable::from((0, 1))); assert_eq!( segments.memory.get(&ptr).unwrap().as_ref(), - &MaybeRelocatable::from(Felt::new(4)) + &MaybeRelocatable::from(Felt252::new(4)) ); } @@ -323,9 +323,9 @@ mod tests { #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn load_data_three_elements() { let data = vec![ - MaybeRelocatable::from(Felt::new(4)), - MaybeRelocatable::from(Felt::new(5)), - MaybeRelocatable::from(Felt::new(6)), + MaybeRelocatable::from(Felt252::new(4)), + MaybeRelocatable::from(Felt252::new(5)), + MaybeRelocatable::from(Felt252::new(6)), ]; let ptr = Relocatable::from((0, 0)); let mut segments = MemorySegmentManager::new(); @@ -335,7 +335,7 @@ mod tests { assert_eq!( segments.memory.get(&ptr).unwrap().as_ref(), - &MaybeRelocatable::from(Felt::new(4)) + &MaybeRelocatable::from(Felt252::new(4)) ); assert_eq!( segments @@ -343,7 +343,7 @@ mod tests { .get(&MaybeRelocatable::from((0, 1))) .unwrap() .as_ref(), - &MaybeRelocatable::from(Felt::new(5)) + &MaybeRelocatable::from(Felt252::new(5)) ); assert_eq!( segments @@ -351,7 +351,7 @@ mod tests { .get(&MaybeRelocatable::from((0, 2))) .unwrap() .as_ref(), - &MaybeRelocatable::from(Felt::new(6)) + &MaybeRelocatable::from(Felt252::new(6)) ); } #[test] @@ -371,7 +371,7 @@ mod tests { .memory .insert( &MaybeRelocatable::from((0, 6)), - &MaybeRelocatable::from(Felt::new(1)), + &MaybeRelocatable::from(Felt252::new(1)), ) .unwrap(); segments.compute_effective_sizes(); @@ -475,7 +475,7 @@ mod tests { let mut big_num = num_bigint::BigInt::from_str_radix(&felt::PRIME_STR[2..], 16) .expect("Couldn't parse prime"); big_num += 1; - let big_maybe_rel = MaybeRelocatable::from(Felt::new(big_num)); + let big_maybe_rel = MaybeRelocatable::from(Felt252::new(big_num)); let data = vec![mayberelocatable!(11), mayberelocatable!(12), big_maybe_rel]; let ptr = Relocatable::from((1, 0)); let mut segments = MemorySegmentManager::new(); From 82089bf980f8122f8449db1c68cd8bc52a0bb72f Mon Sep 17 00:00:00 2001 From: Pedro Fontana Date: Fri, 17 Mar 2023 16:48:09 -0300 Subject: [PATCH 11/15] Add ExecutionResources multiplication (#908) * Add ExecutionResources::Mul * change variables name * typo --------- Co-authored-by: Pedro Fontana --- src/vm/runners/cairo_runner.rs | 73 +++++++++++++++++++++++++++++++++- 1 file changed, 72 insertions(+), 1 deletion(-) diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index 281ad74d1d..71fee7ab83 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -1,7 +1,7 @@ use crate::stdlib::{ any::Any, collections::{HashMap, HashSet}, - ops::{Add, Sub}, + ops::{Add, Mul, Sub}, prelude::*, }; @@ -1160,6 +1160,23 @@ impl Sub for ExecutionResources { } } +impl Mul for ExecutionResources { + type Output = ExecutionResources; + + fn mul(self, rhs: usize) -> ExecutionResources { + let mut total_builtin_instance_counter = self.builtin_instance_counter.clone(); + + for (_builtin_name, counter) in total_builtin_instance_counter.iter_mut() { + *counter *= rhs; + } + + ExecutionResources { + n_steps: rhs * self.n_steps, + n_memory_holes: rhs * self.n_memory_holes, + builtin_instance_counter: total_builtin_instance_counter, + } + } +} #[cfg(test)] mod tests { use super::*; @@ -4699,4 +4716,58 @@ mod tests { let rsc = exec.filter_unused_builtins(); assert_eq!(rsc.builtin_instance_counter.len(), 4); } + + #[test] + fn execution_resources_mul() { + let execution_resources_1 = ExecutionResources { + n_steps: 800, + n_memory_holes: 0, + builtin_instance_counter: HashMap::from([ + ("pedersen_builtin".to_string(), 7), + ("range_check_builtin".to_string(), 16), + ]), + }; + + assert_eq!( + execution_resources_1 * 2, + ExecutionResources { + n_steps: 1600, + n_memory_holes: 0, + builtin_instance_counter: HashMap::from([ + ("pedersen_builtin".to_string(), 14), + ("range_check_builtin".to_string(), 32) + ]) + } + ); + + let execution_resources_2 = ExecutionResources { + n_steps: 545, + n_memory_holes: 0, + builtin_instance_counter: HashMap::from([("range_check_builtin".to_string(), 17)]), + }; + + assert_eq!( + execution_resources_2 * 8, + ExecutionResources { + n_steps: 4360, + n_memory_holes: 0, + builtin_instance_counter: HashMap::from([("range_check_builtin".to_string(), 136)]) + } + ); + + let execution_resources_3 = ExecutionResources { + n_steps: 42, + n_memory_holes: 0, + builtin_instance_counter: HashMap::new(), + }; + + assert_eq!( + execution_resources_3 * 18, + ExecutionResources { + n_steps: 756, + n_memory_holes: 0, + builtin_instance_counter: HashMap::new() + } + ); + } } From f905866a7a734cb38cc4a4a89d2fdf525ae4fdab Mon Sep 17 00:00:00 2001 From: fmoletta <99273364+fmoletta@users.noreply.github.com> Date: Fri, 17 Mar 2023 21:59:15 +0200 Subject: [PATCH 12/15] Remove duplicate cli argument `trace` (#905) `trace` is duplicated from `trace_file` and serves no purpose --- cairo-vm-cli/src/main.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/cairo-vm-cli/src/main.rs b/cairo-vm-cli/src/main.rs index a5e74aa22c..a022ec907a 100644 --- a/cairo-vm-cli/src/main.rs +++ b/cairo-vm-cli/src/main.rs @@ -28,7 +28,6 @@ struct Args { print_output: bool, #[structopt(long = "--entrypoint", default_value = "main")] entrypoint: String, - trace: Option, #[structopt(long = "--memory_file")] memory_file: Option, #[clap(long = "--layout", default_value = "plain", validator=validate_layout)] From d996057ec47d08dfdb215271720a1a55bb8c3b5f Mon Sep 17 00:00:00 2001 From: fmoletta <99273364+fmoletta@users.noreply.github.com> Date: Fri, 17 Mar 2023 22:01:45 +0200 Subject: [PATCH 13/15] Fix compare_becnhmarks target (#904) --- bench/run_benchmarks.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bench/run_benchmarks.sh b/bench/run_benchmarks.sh index e5506de4c9..d44130d21f 100755 --- a/bench/run_benchmarks.sh +++ b/bench/run_benchmarks.sh @@ -1,5 +1,5 @@ #!/usr/bin/env sh -tests_path="cairo_programs/benchmarks" +tests_path="../cairo_programs/benchmarks" set -e @@ -11,5 +11,5 @@ for file in $(ls $tests_path | grep .cairo | sed -E 's/\.cairo//'); do hyperfine \ -n "Cairo VM (CPython)" "PYENV_VERSION=3.7.12 cairo-run --layout all --program $tests_path/$file.json" \ -n "Cairo VM (PyPy)" "PYENV_VERSION=pypy3.7-7.3.9 cairo-run --layout all --program $tests_path/$file.json" \ - -n "cairo-rs (Rust)" "../target/release/cairo-rs-run $tests_path/$file.json --layout all" + -n "cairo-rs (Rust)" "../target/release/cairo-vm-cli $tests_path/$file.json --layout all" done From d4480043ee447212fbde380760302e958bf5adcb Mon Sep 17 00:00:00 2001 From: fmoletta <99273364+fmoletta@users.noreply.github.com> Date: Fri, 17 Mar 2023 22:13:42 +0200 Subject: [PATCH 14/15] Change `Memory.insert` argument types (#902) * Change memory.insert argument types * Remove comented code --- .../builtin_hint_processor/blake2s_utils.rs | 2 +- .../builtin_hint_processor_definition.rs | 47 +++--- .../builtin_hint_processor/dict_hint_utils.rs | 23 +-- .../find_element_hint.rs | 19 +-- .../builtin_hint_processor/math_utils.rs | 14 +- .../builtin_hint_processor/memset_utils.rs | 3 +- .../builtin_hint_processor/pow_utils.rs | 24 ++-- .../secp/field_utils.rs | 82 +++++------ .../builtin_hint_processor/uint256_utils.rs | 10 +- src/utils.rs | 28 ++-- src/vm/errors/memory_errors.rs | 2 +- src/vm/runners/cairo_runner.rs | 18 +-- src/vm/vm_core.rs | 42 +++--- src/vm/vm_memory/memory.rs | 134 +++++------------- src/vm/vm_memory/memory_segments.rs | 4 +- 15 files changed, 194 insertions(+), 258 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs index 046287ce82..3c10196e4b 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs @@ -407,7 +407,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((2, 0)) && + )) if x == Relocatable::from((2, 0)) && y == MaybeRelocatable::from((2, 0)) && z == MaybeRelocatable::from(Felt252::new(1795745351)) ); diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index f24925d87b..4ada688479 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -449,6 +449,7 @@ impl HintProcessor for BuiltinHintProcessor { mod tests { use super::*; use crate::stdlib::any::Any; + use crate::types::relocatable::Relocatable; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -509,17 +510,18 @@ mod tests { add_segments!(vm, 1); //ids and references are not needed for this test assert_matches!( - run_hint!(vm, HashMap::new(), hint_code), - Err(HintError::Memory( - MemoryError::InconsistentMemory( - x, - y, - z - ) - )) if x == MaybeRelocatable::from((1, 6)) && - y == MaybeRelocatable::from((1, 6)) && - z == MaybeRelocatable::from((3, 0)) - ); + run_hint!(vm, HashMap::new(), hint_code), + Err(HintError::Memory( + MemoryError::InconsistentMemory( + x, + y, + z + ) + )) if x == + Relocatable::from((1, 6)) && + y == MaybeRelocatable::from((1, 6)) && + z == MaybeRelocatable::from((3, 0)) + ); } #[test] @@ -623,17 +625,18 @@ mod tests { let ids_data = ids_data!["continue_copying"]; assert_matches!( - run_hint!(vm, ids_data, hint_code, &mut exec_scopes), - Err(HintError::Memory( - MemoryError::InconsistentMemory( - x, - y, - z - ) - )) if x == MaybeRelocatable::from((1, 1)) && - y == MaybeRelocatable::from(Felt252::new(5)) && - z == MaybeRelocatable::from(Felt252::zero()) - ); + run_hint!(vm, ids_data, hint_code, &mut exec_scopes), + Err(HintError::Memory( + MemoryError::InconsistentMemory( + x, + y, + z + ) + )) if x == + Relocatable::from((1, 1)) && + y == MaybeRelocatable::from(Felt252::new(5)) && + z == MaybeRelocatable::from(Felt252::zero()) + ); } #[test] diff --git a/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs b/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs index 3767fce2ff..f3108bf776 100644 --- a/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs +++ b/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs @@ -330,17 +330,18 @@ mod tests { vm.segments = segments![((1, 0), 1)]; //ids and references are not needed for this test assert_matches!( - run_hint!(vm, HashMap::new(), hint_code, &mut exec_scopes), - Err(HintError::Memory( - MemoryError::InconsistentMemory( - x, - y, - z - ) - )) if x == MaybeRelocatable::from((1, 0)) && - y == MaybeRelocatable::from(1) && - z == MaybeRelocatable::from((2, 0)) - ); + run_hint!(vm, HashMap::new(), hint_code, &mut exec_scopes), + Err(HintError::Memory( + MemoryError::InconsistentMemory( + x, + y, + z + ) + )) if x == + Relocatable::from((1, 0)) && + y == MaybeRelocatable::from(1) && + z == MaybeRelocatable::from((2, 0)) + ); } #[test] diff --git a/src/hint_processor/builtin_hint_processor/find_element_hint.rs b/src/hint_processor/builtin_hint_processor/find_element_hint.rs index 390bbb7cf0..235ba2e080 100644 --- a/src/hint_processor/builtin_hint_processor/find_element_hint.rs +++ b/src/hint_processor/builtin_hint_processor/find_element_hint.rs @@ -134,6 +134,7 @@ pub fn search_sorted_lower( mod tests { use super::*; use crate::stdlib::string::ToString; + use crate::types::relocatable::Relocatable; use crate::{ any_box, hint_processor::{ @@ -166,14 +167,14 @@ mod tests { } let addresses = vec![ - MaybeRelocatable::from((1, 0)), - MaybeRelocatable::from((1, 1)), - MaybeRelocatable::from((1, 2)), - MaybeRelocatable::from((1, 4)), - MaybeRelocatable::from((2, 0)), - MaybeRelocatable::from((2, 1)), - MaybeRelocatable::from((2, 2)), - MaybeRelocatable::from((2, 3)), + Relocatable::from((1, 0)), + Relocatable::from((1, 1)), + Relocatable::from((1, 2)), + Relocatable::from((1, 4)), + Relocatable::from((2, 0)), + Relocatable::from((2, 1)), + Relocatable::from((2, 2)), + Relocatable::from((2, 3)), ]; let default_values = vec![ @@ -203,7 +204,7 @@ mod tests { .unwrap_or(&default_values[i].1); vm.segments .memory - .insert(memory_cell, value_to_insert) + .insert(*memory_cell, value_to_insert) .expect("Unexpected memory insert fail"); } let mut ids_data = HashMap::::new(); diff --git a/src/hint_processor/builtin_hint_processor/math_utils.rs b/src/hint_processor/builtin_hint_processor/math_utils.rs index b1968ae966..8f91a97b60 100644 --- a/src/hint_processor/builtin_hint_processor/math_utils.rs +++ b/src/hint_processor/builtin_hint_processor/math_utils.rs @@ -773,7 +773,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((1, 0)) && + )) if x == Relocatable::from((1, 0)) && y == MaybeRelocatable::Int(Felt252::one()) && z == MaybeRelocatable::Int(Felt252::zero()) ); @@ -1382,7 +1382,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((1, 1)) && + )) if x == Relocatable::from((1, 1)) && y == MaybeRelocatable::from(Felt252::new(4)) && z == MaybeRelocatable::from(Felt252::one()) ); @@ -1445,7 +1445,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((1, 1)) && + )) if x == Relocatable::from((1, 1)) && y == MaybeRelocatable::from(Felt252::new(7)) && z == MaybeRelocatable::from(Felt252::new(9)) ); @@ -1527,7 +1527,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((1, 0)) && + )) if x == Relocatable::from((1, 0)) && y == MaybeRelocatable::Int(Felt252::new(5)) && z == MaybeRelocatable::Int(Felt252::new(2)) ); @@ -1643,7 +1643,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((1, 1)) && + )) if x == Relocatable::from((1, 1)) && y == MaybeRelocatable::Int(Felt252::new(10)) && z == MaybeRelocatable::Int(Felt252::new(31)) ); @@ -1790,7 +1790,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((2, 0)) && + )) if x == Relocatable::from((2, 0)) && y == MaybeRelocatable::from(Felt252::new(99)) && z == MaybeRelocatable::from(felt_str!("335438970432432812899076431678123043273")) ); @@ -1825,7 +1825,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((2, 1)) && + )) if x == Relocatable::from((2, 1)) && y == MaybeRelocatable::from(Felt252::new(99)) && z == MaybeRelocatable::from(Felt252::new(0)) ); diff --git a/src/hint_processor/builtin_hint_processor/memset_utils.rs b/src/hint_processor/builtin_hint_processor/memset_utils.rs index 0065c38223..46cca7ea40 100644 --- a/src/hint_processor/builtin_hint_processor/memset_utils.rs +++ b/src/hint_processor/builtin_hint_processor/memset_utils.rs @@ -58,6 +58,7 @@ pub fn memset_continue_loop( mod tests { use super::*; use crate::stdlib::string::ToString; + use crate::types::relocatable::Relocatable; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -188,7 +189,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((1, 0)) && + )) if x == Relocatable::from((1, 0)) && y == MaybeRelocatable::from(Felt252::new(5)) && z == MaybeRelocatable::from(Felt252::zero()) ); diff --git a/src/hint_processor/builtin_hint_processor/pow_utils.rs b/src/hint_processor/builtin_hint_processor/pow_utils.rs index 5cad6a95ee..ac813c5064 100644 --- a/src/hint_processor/builtin_hint_processor/pow_utils.rs +++ b/src/hint_processor/builtin_hint_processor/pow_utils.rs @@ -43,6 +43,7 @@ pub fn pow( #[cfg(test)] mod tests { use super::*; + use crate::types::relocatable::Relocatable; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use crate::{ any_box, @@ -144,16 +145,17 @@ mod tests { vm.segments = segments![((1, 10), 3), ((1, 11), 3)]; //Execute the hint assert_matches!( - run_hint!(vm, ids_data, hint_code), - Err(HintError::Memory( - MemoryError::InconsistentMemory( - x, - y, - z - ) - )) if x == MaybeRelocatable::from((1, 11)) && - y == MaybeRelocatable::from(Felt252::new(3)) && - z == MaybeRelocatable::from(Felt252::one()) - ); + run_hint!(vm, ids_data, hint_code), + Err(HintError::Memory( + MemoryError::InconsistentMemory( + x, + y, + z + ) + )) if x == + Relocatable::from((1, 11)) && + y == MaybeRelocatable::from(Felt252::new(3)) && + z == MaybeRelocatable::from(Felt252::one()) + ); } } diff --git a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs index aad73265b0..a4472985b6 100644 --- a/src/hint_processor/builtin_hint_processor/secp/field_utils.rs +++ b/src/hint_processor/builtin_hint_processor/secp/field_utils.rs @@ -278,35 +278,36 @@ mod tests { vm.segments = segments![((1, 4), 0), ((1, 5), 0), ((1, 6), 0), ((1, 9), 55)]; //Execute the hint assert_matches!( - run_hint!( - vm, - ids_data, - hint_code, - exec_scopes_ref!(), - &[( - SECP_REM, - Felt252::one().shl(32_u32) - + Felt252::one().shl(9_u32) - + Felt252::one().shl(8_u32) - + Felt252::one().shl(7_u32) - + Felt252::one().shl(6_u32) - + Felt252::one().shl(4_u32) - + Felt252::one() - )] - .into_iter() - .map(|(k, v)| (k.to_string(), v)) - .collect() - ), - Err(HintError::Memory( - MemoryError::InconsistentMemory( - x, - y, - z - ) - )) if x == MaybeRelocatable::from((1, 9)) && - y == MaybeRelocatable::from(Felt252::new(55_i32)) && - z == MaybeRelocatable::from(Felt252::zero()) - ); + run_hint!( + vm, + ids_data, + hint_code, + exec_scopes_ref!(), + &[( + SECP_REM, + Felt252::one().shl(32_u32) + + Felt252::one().shl(9_u32) + + Felt252::one().shl(8_u32) + + Felt252::one().shl(7_u32) + + Felt252::one().shl(6_u32) + + Felt252::one().shl(4_u32) + + Felt252::one() + )] + .into_iter() + .map(|(k, v)| (k.to_string(), v)) + .collect() + ), + Err(HintError::Memory( + MemoryError::InconsistentMemory( + x, + y, + z + ) + )) if x == + Relocatable::from((1, 9)) && + y == MaybeRelocatable::from(Felt252::new(55_i32)) && + z == MaybeRelocatable::from(Felt252::zero()) + ); } #[test] @@ -589,17 +590,18 @@ mod tests { exec_scopes.assign_or_update_variable("x", any_box!(BigInt::zero())); //Execute the hint assert_matches!( - run_hint!(vm, HashMap::new(), hint_code, &mut exec_scopes), - Err(HintError::Memory( - MemoryError::InconsistentMemory( - x, - y, - z - ) - )) if x == MaybeRelocatable::from(vm.run_context.get_ap()) && - y == MaybeRelocatable::from(Felt252::new(55i32)) && - z == MaybeRelocatable::from(Felt252::new(1i32)) - ); + run_hint!(vm, HashMap::new(), hint_code, &mut exec_scopes), + Err(HintError::Memory( + MemoryError::InconsistentMemory( + x, + y, + z + ) + )) if x == + vm.run_context.get_ap() && + y == MaybeRelocatable::from(Felt252::new(55i32)) && + z == MaybeRelocatable::from(Felt252::new(1i32)) + ); } #[test] diff --git a/src/hint_processor/builtin_hint_processor/uint256_utils.rs b/src/hint_processor/builtin_hint_processor/uint256_utils.rs index 0eb2b51e48..01cec6b97c 100644 --- a/src/hint_processor/builtin_hint_processor/uint256_utils.rs +++ b/src/hint_processor/builtin_hint_processor/uint256_utils.rs @@ -294,7 +294,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((1, 12)) && + )) if x == Relocatable::from((1, 12)) && y == MaybeRelocatable::from(Felt252::new(2)) && z == MaybeRelocatable::from(Felt252::zero()) ); @@ -368,7 +368,7 @@ mod tests { y, z ) - )) if x == MaybeRelocatable::from((1, 10)) && + )) if x == Relocatable::from((1, 10)) && y == MaybeRelocatable::from(Felt252::zero()) && z == MaybeRelocatable::from(felt_str!("7249717543555297151")) ); @@ -437,7 +437,7 @@ mod tests { y, z, ) - )) if x == MaybeRelocatable::from((1, 5)) && + )) if x == Relocatable::from((1, 5)) && y == MaybeRelocatable::from(Felt252::one()) && z == MaybeRelocatable::from(felt_str!("48805497317890012913")) ); @@ -510,7 +510,7 @@ mod tests { y, z, ) - )) if x == MaybeRelocatable::from((1, 5)) && + )) if x == Relocatable::from((1, 5)) && y == MaybeRelocatable::from(Felt252::new(55)) && z == MaybeRelocatable::from(Felt252::one()) ); @@ -568,7 +568,7 @@ mod tests { y, z, ) - )) if x == MaybeRelocatable::from((1, 10)) && + )) if x == Relocatable::from((1, 10)) && y == MaybeRelocatable::from(Felt252::zero()) && z == MaybeRelocatable::from(Felt252::new(10)) ); diff --git a/src/utils.rs b/src/utils.rs index 8616f12476..15f1552c43 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -139,10 +139,7 @@ pub mod test_utils { macro_rules! memory_inner { ($mem:expr, ($si:expr, $off:expr), ($sival:expr, $offval: expr)) => { - let (k, v) = ( - &mayberelocatable!($si, $off), - &mayberelocatable!($sival, $offval), - ); + let (k, v) = (($si, $off).into(), &mayberelocatable!($sival, $offval)); let mut res = $mem.insert(k, v); while matches!(res, Err(MemoryError::UnallocatedSegment(_, _))) { if $si < 0 { @@ -154,7 +151,7 @@ pub mod test_utils { } }; ($mem:expr, ($si:expr, $off:expr), $val:expr) => { - let (k, v) = (&mayberelocatable!($si, $off), &mayberelocatable!($val)); + let (k, v) = (($si, $off).into(), &mayberelocatable!($val)); let mut res = $mem.insert(k, v); while matches!(res, Err(MemoryError::UnallocatedSegment(_, _))) { if $si < 0 { @@ -567,15 +564,12 @@ mod test { } memory .insert( - &MaybeRelocatable::from((1, 2)), + Relocatable::from((1, 2)), &MaybeRelocatable::from(Felt252::one()), ) .unwrap(); memory - .insert( - &MaybeRelocatable::from((1, 1)), - &MaybeRelocatable::from((1, 0)), - ) + .insert(Relocatable::from((1, 1)), &MaybeRelocatable::from((1, 0))) .unwrap(); let mem = memory![((1, 2), 1), ((1, 1), (1, 0))]; assert_eq!(memory.data, mem.data); @@ -589,15 +583,12 @@ mod test { memory.data.push(Vec::new()); } memory - .insert( - &MaybeRelocatable::from((1, 1)), - &MaybeRelocatable::from((1, 0)), - ) + .insert(Relocatable::from((1, 1)), &MaybeRelocatable::from((1, 0))) .unwrap(); memory .insert( - &MaybeRelocatable::from((1, 2)), + Relocatable::from((1, 2)), &MaybeRelocatable::from(Felt252::one()), ) .unwrap(); @@ -613,15 +604,12 @@ mod test { memory.data.push(Vec::new()); } memory - .insert( - &MaybeRelocatable::from((1, 1)), - &MaybeRelocatable::from((1, 0)), - ) + .insert(Relocatable::from((1, 1)), &MaybeRelocatable::from((1, 0))) .unwrap(); memory .insert( - &MaybeRelocatable::from((1, 2)), + Relocatable::from((1, 2)), &MaybeRelocatable::from(Felt252::one()), ) .unwrap(); diff --git a/src/vm/errors/memory_errors.rs b/src/vm/errors/memory_errors.rs index 9b2e0abb09..5bdf7f96fd 100644 --- a/src/vm/errors/memory_errors.rs +++ b/src/vm/errors/memory_errors.rs @@ -23,7 +23,7 @@ pub enum MemoryError { #[error("Range-check validation failed, encountered non-int value at address {0}")] RangeCheckFoundNonInt(Relocatable), #[error("Inconsistent memory assignment at address {0:?}. {1:?} != {2:?}")] - InconsistentMemory(MaybeRelocatable, MaybeRelocatable, MaybeRelocatable), + InconsistentMemory(Relocatable, MaybeRelocatable, MaybeRelocatable), #[error("Inconsistent Relocation")] Relocation, #[error("Could not cast arguments")] diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index 71fee7ab83..c8842fc7d1 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -2325,42 +2325,36 @@ mod tests { vm.segments .memory .insert( - &MaybeRelocatable::from((0, 0)), + Relocatable::from((0, 0)), &MaybeRelocatable::from(Felt252::new(4613515612218425347_i64)), ) .unwrap(); vm.segments .memory .insert( - &MaybeRelocatable::from((0, 1)), + Relocatable::from((0, 1)), &MaybeRelocatable::from(Felt252::new(5)), ) .unwrap(); vm.segments .memory .insert( - &MaybeRelocatable::from((0, 2)), + Relocatable::from((0, 2)), &MaybeRelocatable::from(Felt252::new(2345108766317314046_i64)), ) .unwrap(); vm.segments .memory - .insert( - &MaybeRelocatable::from((1, 0)), - &MaybeRelocatable::from((2, 0)), - ) + .insert(Relocatable::from((1, 0)), &MaybeRelocatable::from((2, 0))) .unwrap(); vm.segments .memory - .insert( - &MaybeRelocatable::from((1, 1)), - &MaybeRelocatable::from((3, 0)), - ) + .insert(Relocatable::from((1, 1)), &MaybeRelocatable::from((3, 0))) .unwrap(); vm.segments .memory .insert( - &MaybeRelocatable::from((1, 5)), + Relocatable::from((1, 5)), &MaybeRelocatable::from(Felt252::new(5)), ) .unwrap(); diff --git a/src/vm/vm_core.rs b/src/vm/vm_core.rs index 791b863a7b..1bda0ebda6 100644 --- a/src/vm/vm_core.rs +++ b/src/vm/vm_core.rs @@ -397,19 +397,19 @@ impl VirtualMachine { if deduced_operands.was_op0_deducted() { self.segments .memory - .insert(&operands_addresses.op0_addr, &operands.op0) + .insert(operands_addresses.op0_addr, &operands.op0) .map_err(VirtualMachineError::Memory)?; } if deduced_operands.was_op1_deducted() { self.segments .memory - .insert(&operands_addresses.op1_addr, &operands.op1) + .insert(operands_addresses.op1_addr, &operands.op1) .map_err(VirtualMachineError::Memory)?; } if deduced_operands.was_dest_deducted() { self.segments .memory - .insert(&operands_addresses.dst_addr, &operands.dst) + .insert(operands_addresses.dst_addr, &operands.dst) .map_err(VirtualMachineError::Memory)?; } @@ -2568,23 +2568,23 @@ mod tests { } vm.segments.memory.data.push(Vec::new()); - let dst_addr = MaybeRelocatable::from((1, 0)); + let dst_addr = Relocatable::from((1, 0)); let dst_addr_value = MaybeRelocatable::Int(Felt252::new(5)); - let op0_addr = MaybeRelocatable::from((1, 1)); + let op0_addr = Relocatable::from((1, 1)); let op0_addr_value = MaybeRelocatable::Int(Felt252::new(2)); - let op1_addr = MaybeRelocatable::from((1, 2)); + let op1_addr = Relocatable::from((1, 2)); let op1_addr_value = MaybeRelocatable::Int(Felt252::new(3)); vm.segments .memory - .insert(&dst_addr, &dst_addr_value) + .insert(dst_addr, &dst_addr_value) .unwrap(); vm.segments .memory - .insert(&op0_addr, &op0_addr_value) + .insert(op0_addr, &op0_addr_value) .unwrap(); vm.segments .memory - .insert(&op1_addr, &op1_addr_value) + .insert(op1_addr, &op1_addr_value) .unwrap(); let expected_operands = Operands { @@ -2595,9 +2595,9 @@ mod tests { }; let expected_addresses = OperandsAddresses { - dst_addr: dst_addr.get_relocatable().unwrap(), - op0_addr: op0_addr.get_relocatable().unwrap(), - op1_addr: op1_addr.get_relocatable().unwrap(), + dst_addr, + op0_addr, + op1_addr, }; let (operands, addresses, _) = vm.compute_operands(&inst).unwrap(); @@ -2628,23 +2628,23 @@ mod tests { vm.segments.add(); } vm.segments.memory.data.push(Vec::new()); - let dst_addr = mayberelocatable!(1, 0); + let dst_addr = relocatable!(1, 0); let dst_addr_value = mayberelocatable!(6); - let op0_addr = mayberelocatable!(1, 1); + let op0_addr = relocatable!(1, 1); let op0_addr_value = mayberelocatable!(2); - let op1_addr = mayberelocatable!(1, 2); + let op1_addr = relocatable!(1, 2); let op1_addr_value = mayberelocatable!(3); vm.segments .memory - .insert(&dst_addr, &dst_addr_value) + .insert(dst_addr, &dst_addr_value) .unwrap(); vm.segments .memory - .insert(&op0_addr, &op0_addr_value) + .insert(op0_addr, &op0_addr_value) .unwrap(); vm.segments .memory - .insert(&op1_addr, &op1_addr_value) + .insert(op1_addr, &op1_addr_value) .unwrap(); let expected_operands = Operands { @@ -2655,9 +2655,9 @@ mod tests { }; let expected_addresses = OperandsAddresses { - dst_addr: dst_addr.get_relocatable().unwrap(), - op0_addr: op0_addr.get_relocatable().unwrap(), - op1_addr: op1_addr.get_relocatable().unwrap(), + dst_addr, + op0_addr, + op1_addr, }; let (operands, addresses, _) = vm.compute_operands(&inst).unwrap(); diff --git a/src/vm/vm_memory/memory.rs b/src/vm/vm_memory/memory.rs index f9400e0e0e..607e32dfa0 100644 --- a/src/vm/vm_memory/memory.rs +++ b/src/vm/vm_memory/memory.rs @@ -63,22 +63,19 @@ impl Memory { validation_rules: HashMap::new(), } } + /// Inserts a value into a memory address /// Will return an Error if the segment index given by the address corresponds to a non-allocated segment, /// or if the inserted value is inconsistent with the current value at the memory cell /// If the address isnt contiguous with previously inserted data, memory gaps will be represented by None values - pub fn insert<'a, K: 'a, V: 'a>(&mut self, key: &'a K, val: &'a V) -> Result<(), MemoryError> + pub fn insert(&mut self, key: Relocatable, val: V) -> Result<(), MemoryError> where - Relocatable: TryFrom<&'a K>, - MaybeRelocatable: From<&'a V>, + MaybeRelocatable: From, { - let relocatable: Relocatable = key - .try_into() - .map_err(|_| MemoryError::AddressNotRelocatable)?; let val = MaybeRelocatable::from(val); - let (value_index, value_offset) = from_relocatable_to_indexes(relocatable); + let (value_index, value_offset) = from_relocatable_to_indexes(key); - let data = if relocatable.segment_index.is_negative() { + let data = if key.segment_index.is_negative() { &mut self.temp_data } else { &mut self.data @@ -102,14 +99,14 @@ impl Memory { if current_cell.get_value() != &val { //Existing memory cannot be changed return Err(MemoryError::InconsistentMemory( - relocatable.into(), + key, current_cell.get_value().clone(), val, )); } } }; - self.validate_memory_cell(relocatable) + self.validate_memory_cell(key) } /// Retrieve a value from memory (either normal or temporary) and apply relocation rules @@ -174,7 +171,7 @@ impl Memory { for cell in data_segment { if let Some(cell) = cell { // Rely on Memory::insert to catch memory inconsistencies - self.insert(&addr, cell.get_value())?; + self.insert(addr, cell.get_value())?; } addr = (addr + 1)?; } @@ -242,7 +239,7 @@ impl Memory { key: Relocatable, val: T, ) -> Result<(), MemoryError> { - self.insert(&key, &val.into()) + self.insert(key, &val.into()) } pub fn add_validation_rule(&mut self, segment_index: usize, rule: ValidationRule) { @@ -451,28 +448,14 @@ mod memory_tests { #[cfg(target_arch = "wasm32")] use wasm_bindgen_test::*; - pub fn memory_from( - key_val_list: Vec<(MaybeRelocatable, MaybeRelocatable)>, - num_segements: usize, - ) -> Result { - let mut memory = Memory::new(); - for _ in 0..num_segements { - memory.data.push(Vec::new()); - } - for (key, val) in key_val_list.iter() { - memory.insert(key, val)?; - } - Ok(memory) - } - #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_succesful() { - let key = MaybeRelocatable::from((0, 0)); + let key = Relocatable::from((0, 0)); let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); memory.data.push(Vec::new()); - memory.insert(&key, &val).unwrap(); + memory.insert(key, &val).unwrap(); assert_eq!( memory.get(&key).unwrap().as_ref(), &MaybeRelocatable::from(Felt252::new(5)) @@ -497,11 +480,11 @@ mod memory_tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_value_in_temp_segment() { - let key = MaybeRelocatable::from((-1, 3)); + let key = Relocatable::from((-1, 3)); let val = MaybeRelocatable::from(Felt252::new(8)); let mut memory = Memory::new(); memory.temp_data.push(Vec::new()); - memory.insert(&key, &val).unwrap(); + memory.insert(key, &val).unwrap(); assert_eq!( memory.temp_data[0][3], Some(MemoryCell::new(MaybeRelocatable::from(Felt252::new(8)))) @@ -511,11 +494,11 @@ mod memory_tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_succesful() { - let key = MaybeRelocatable::from((-1, 0)); + let key = Relocatable::from((-1, 0)); let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); memory.temp_data.push(Vec::new()); - memory.insert(&key, &val).unwrap(); + memory.insert(key, &val).unwrap(); assert_eq!( memory.get(&key).unwrap().as_ref(), &MaybeRelocatable::from(Felt252::new(5)), @@ -525,13 +508,13 @@ mod memory_tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_and_get_from_temp_segment_failed() { - let key = mayberelocatable!(-1, 1); + let key = relocatable!(-1, 1); let mut memory = Memory::new(); memory.temp_data = vec![vec![None, Some(MemoryCell::new(mayberelocatable!(8)))]]; assert_eq!( - memory.insert(&key, &mayberelocatable!(5)), + memory.insert(key, &mayberelocatable!(5)), Err(MemoryError::InconsistentMemory( - mayberelocatable!(-1, 1), + relocatable!(-1, 1), mayberelocatable!(8), mayberelocatable!(5) )) @@ -541,7 +524,7 @@ mod memory_tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_allocated_memory() { - let key = MaybeRelocatable::from((0, 0)); + let key = Relocatable::from((0, 0)); let memory = Memory::new(); assert_eq!(memory.get(&key), None); } @@ -549,84 +532,62 @@ mod memory_tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn get_non_existant_element() { - let key = MaybeRelocatable::from((0, 0)); + let key = Relocatable::from((0, 0)); let memory = Memory::new(); assert_eq!(memory.get(&key), None); } - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn get_non_relocatable_key() { - let key = MaybeRelocatable::from(Felt252::new(0)); - let memory = Memory::new(); - assert!(memory.get(&key).is_none()); - } - #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_allocated_memory() { - let key = MaybeRelocatable::from((0, 0)); + let key = Relocatable::from((0, 0)); let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); - let error = memory.insert(&key, &val); + let error = memory.insert(key, &val); assert_eq!(error, Err(MemoryError::UnallocatedSegment(0, 0))); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_inconsistent_memory() { - let key = MaybeRelocatable::from((0, 0)); + let key = Relocatable::from((0, 0)); let val_a = MaybeRelocatable::from(Felt252::new(5)); let val_b = MaybeRelocatable::from(Felt252::new(6)); let mut memory = Memory::new(); memory.data.push(Vec::new()); memory - .insert(&key, &val_a) + .insert(key, &val_a) .expect("Unexpected memory insert fail"); - let error = memory.insert(&key, &val_b); + let error = memory.insert(key, &val_b); assert_eq!( error, Err(MemoryError::InconsistentMemory(key, val_a, val_b)) ); } - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn insert_address_not_relocatable() { - let key = MaybeRelocatable::from(Felt252::new(5)); - let val = MaybeRelocatable::from(Felt252::new(5)); - let mut memory = Memory::new(); - let error = memory.insert(&key, &val); - assert_eq!(error, Err(MemoryError::AddressNotRelocatable)); - assert_eq!( - error.unwrap_err().to_string(), - "Memory addresses must be relocatable" - ); - } - #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_contiguous_element() { - let key_a = MaybeRelocatable::from((0, 0)); - let key_b = MaybeRelocatable::from((0, 2)); + let key_a = Relocatable::from((0, 0)); + let key_b = Relocatable::from((0, 2)); let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); memory.data.push(Vec::new()); - memory.insert(&key_a, &val).unwrap(); - memory.insert(&key_b, &val).unwrap(); + memory.insert(key_a, &val).unwrap(); + memory.insert(key_b, &val).unwrap(); assert_eq!(memory.get(&key_b).unwrap().as_ref(), &val); } #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn insert_non_contiguous_element_memory_gaps_none() { - let key_a = MaybeRelocatable::from((0, 0)); - let key_b = MaybeRelocatable::from((0, 5)); + let key_a = Relocatable::from((0, 0)); + let key_b = Relocatable::from((0, 5)); let val = MaybeRelocatable::from(Felt252::new(5)); let mut memory = Memory::new(); memory.data.push(Vec::new()); - memory.insert(&key_a, &val).unwrap(); - memory.insert(&key_b, &val).unwrap(); + memory.insert(key_a, &val).unwrap(); + memory.insert(key_b, &val).unwrap(); assert_eq!(memory.get(&key_b).unwrap().as_ref(), &val); assert_eq!(memory.get(&MaybeRelocatable::from((0, 1))), None); assert_eq!(memory.get(&MaybeRelocatable::from((0, 2))), None); @@ -634,20 +595,6 @@ mod memory_tests { assert_eq!(memory.get(&MaybeRelocatable::from((0, 4))), None); } - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn from_array_test() { - let mem = memory_from( - vec![( - MaybeRelocatable::from((1, 0)), - MaybeRelocatable::from(Felt252::new(5)), - )], - 2, - ) - .unwrap(); - assert_matches!(mem.get(&MaybeRelocatable::from((1, 0))), Some(inner) if inner.clone().into_owned() == MaybeRelocatable::Int(Felt252::new(5))); - } - #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn validate_existing_memory_for_range_check_within_bounds() { @@ -662,7 +609,7 @@ mod memory_tests { segments .memory .insert( - &MaybeRelocatable::from((0, 0)), + Relocatable::from((0, 0)), &MaybeRelocatable::from(Felt252::new(45)), ) .unwrap(); @@ -683,7 +630,7 @@ mod memory_tests { segments .memory .insert( - &MaybeRelocatable::from((1, 0)), + Relocatable::from((1, 0)), &MaybeRelocatable::from(Felt252::new(-10)), ) .unwrap(); @@ -789,7 +736,7 @@ mod memory_tests { segments .memory .insert( - &MaybeRelocatable::from((0, 0)), + Relocatable::from((0, 0)), &MaybeRelocatable::from(Felt252::new(-45)), ) .unwrap(); @@ -817,10 +764,7 @@ mod memory_tests { segments.add(); segments .memory - .insert( - &MaybeRelocatable::from((0, 0)), - &MaybeRelocatable::from((0, 10)), - ) + .insert(Relocatable::from((0, 0)), &MaybeRelocatable::from((0, 10))) .unwrap(); assert_matches!( segments.memory.get_integer(Relocatable::from((0, 0))), @@ -843,9 +787,9 @@ mod memory_tests { let mut memory = Memory::new(); memory.temp_data.push(Vec::new()); - let key = MaybeRelocatable::from((-1, 0)); + let key = Relocatable::from((-1, 0)); let val = MaybeRelocatable::from(Felt252::new(5)); - memory.insert(&key, &val).unwrap(); + memory.insert(key, &val).unwrap(); assert_eq!(memory.get(&key).unwrap().as_ref(), &val); } diff --git a/src/vm/vm_memory/memory_segments.rs b/src/vm/vm_memory/memory_segments.rs index 2289aab467..492cbfc76d 100644 --- a/src/vm/vm_memory/memory_segments.rs +++ b/src/vm/vm_memory/memory_segments.rs @@ -56,7 +56,7 @@ impl MemorySegmentManager { data: &Vec, ) -> Result { for (num, value) in data.iter().enumerate() { - self.memory.insert(&(ptr + num)?, value)?; + self.memory.insert((ptr + num)?, value)?; } (ptr + data.len()).map_err(MemoryError::Math) } @@ -370,7 +370,7 @@ mod tests { segments .memory .insert( - &MaybeRelocatable::from((0, 6)), + Relocatable::from((0, 6)), &MaybeRelocatable::from(Felt252::new(1)), ) .unwrap(); From 40d83255474d57a1e1fb31d540519494607093a9 Mon Sep 17 00:00:00 2001 From: Mario Rugiero Date: Fri, 17 Mar 2023 17:18:01 -0300 Subject: [PATCH 15/15] Use mimalloc in benchmarks (#897) --- bench/criterion_benchmark.rs | 7 +++++++ bench/iai_benchmark.rs | 7 +++++++ 2 files changed, 14 insertions(+) diff --git a/bench/criterion_benchmark.rs b/bench/criterion_benchmark.rs index 2ca326bbce..032e38c305 100644 --- a/bench/criterion_benchmark.rs +++ b/bench/criterion_benchmark.rs @@ -6,6 +6,13 @@ use cairo_vm::{ }; use criterion::{black_box, criterion_group, criterion_main, Criterion}; +#[cfg(feature = "with_mimalloc")] +use mimalloc::MiMalloc; + +#[cfg(feature = "with_mimalloc")] +#[global_allocator] +static ALLOC: MiMalloc = MiMalloc; + const BENCH_NAMES: &[&str] = &[ "compare_arrays_200000", "factorial_multirun", diff --git a/bench/iai_benchmark.rs b/bench/iai_benchmark.rs index 3ffb5e1839..55d42cf25f 100644 --- a/bench/iai_benchmark.rs +++ b/bench/iai_benchmark.rs @@ -46,6 +46,13 @@ impl FileWriter { } } +#[cfg(feature = "with_mimalloc")] +use mimalloc::MiMalloc; + +#[cfg(feature = "with_mimalloc")] +#[global_allocator] +static ALLOC: MiMalloc = MiMalloc; + macro_rules! iai_bench_expand_prog { ($val: ident) => { fn $val() {