lambdaclass / cairo-vm Goto Github PK

https://github.com/sharkdp/hyperfine

Move all cairo programs to a cairo_programs folder for the benchmark and comparison (memory output and trace output comparison) testing.

• Expected output: a good walkthrough on how existing hints work in cairo and oraic

Right now the program only supports a few different options and we have many IFs that check the different options to decide what to call next. This could be split up into different functions and this functions could be called from main using a match on the arguments of the program instead.

Perhaps the is_zero function in vm_core might be improved by using the is_zero method from the num_bigint library instead of constructing a zero value and comparing against it.

• Research which fuzzy testing Rust tool to use.
• Find possible areas in cleopatra in which to apply fuzzing testing.
• Expected output: a decision on which fuzzy testing library to use and which tests to add.

https://medium.com/nerd-for-tech/ci-build-performance-testing-with-github-action-e6b227097c83

Range check builtin doesn't have online validation. When the vm writes an invalid value to the range check builtin we should get an immediate error, so we know where the issue happened.

Remove all the Cairo compiled programs (program.json files) from the Repo.

Programs should be compiled using the python cairo compiler.

Research about Cairo hints and how to integrate them in a Rust CairoVM

Currently, VirtualMachine contains a context (RunContext) with a Memory, and it (VirtualMachine) also contains a ValidatedMemoryDict which also contains a Memory. Both of this Memories contain the same information, in order to avoid double reference/ duplication, we could keep only one Memory in VirtualMachine (removing memory from the context and getting rid of ValidatedMemoryDict altogether), and move the validated_addresses to VirtualMachine.

Check: https://github.com/yatima-inc/yatima

• https://www.cairo-lang.org/docs/how_cairo_works/consts.html#temporary-variables
• https://www.cairo-lang.org/docs/how_cairo_works/consts.html#local-variables

Replace unwraps for proper handling and error display in cairo_run

Currently the entrypoint to the cairo file being run is hardcoded to the main function.
Since we'd like at Onlydust to leverage your VM to build a fast Cairo test runner, we would need to be able to specify a different entrypoint, let's say my_function for example.

I plan to work on this, I open the issue to start the conversation and get your point of view on this.

https://rust-lang.github.io/rustup/overrides.html#the-toolchain-file

Add mode/flag to run the vm without storing the execution trace. A lot of scenarios don't need it, and it just takes memory for no reason

Here is my code:

%builtins output pedersen

from starkware.cairo.common.cairo_builtins import HashBuiltin
from starkware.cairo.common.hash import hash2

func main{output_ptr, pedersen_ptr: HashBuiltin*}():
    let (res) = hash2{hash_ptr=pedersen_ptr}(1, 2)

    res = [output_ptr]

    let output_ptr = output_ptr + 1
    return()
end

cairo-compile && cairo-run works

cairo-compile check_hash.cairo --output check_hash_compiled.json
cairo-run --program=check_hash_compiled.json --layout=small --print_output 
Program output:
  -1025514936890165471153863463586721648332140962090141185746964417035414175707

But cleaopatra doesn't

cargo run -- ~/Documents/rusty-crew/cairo_test/check_hash_compiled.json  
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/cleopatra-run /Users/tdelabro/Documents/rusty-crew/cairo_test/check_hash_compiled.json`
thread 'main' panicked at 'Couldn't compute or deduce op1', src/vm/vm_core.rs:441:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Why is that ?

https://docs.rs/dhat/latest/dhat/

Check https://github.com/lurk-lang/lurk as reference

Eventually, we will want to have tests that ensure parity across Cairo VM implementations.
How exactly to achieve that is an open question, but it will likely involve a Python testing framework.

• Research and document
  • how tests are run in the cairo-lang repositor,
  • what kind of tests they are,
  • what they test,
  • what dependencies they have
  • and if possible, how they could be made vm-agnostic.

Expected outcome: a through discussion on how to test results of different vm implementations.

Check: https://github.com/filecoin-project/neptune/blob/master/.circleci/config.yml

We should be able to output the relocated memory to a file like cairo_run does.

The kani rust verifier project might be useful.

• Research the tool and it's best uses.
• Find if possible applications within cleopatra
• Expected output: an informed discussion on how to best use formal verification.

Resources:

• https://model-checking.github.io//kani-verifier-blog/2022/05/04/announcing-the-kani-rust-verifier-project.html
• https://github.com/model-checking/kani
• https://news.ycombinator.com/item?id=30786511
• https://news.ycombinator.com/item?id=31266495
• https://www.reddit.com/r/rust/comments/uic2dy/announcing_the_kani_rust_verifier_project/
• https://model-checking.github.io/kani/

Current documentation of add(&mut self, memory: &mut Memory, size: Option<usize>):

If size is not None the segment is finalized with the given size

is not implemented

• The rustdoc comments should be polished and expanded in general.
• cleopatra is yet green to publish to crate.io and thus docs.rs but perhaps work could be done on the CI to add the rendered docs to the repo's github pages.

Add sha256 to the tests and benchmarks
https://github.com/Th0rgal/sphinx/blob/master/src/sphinx/sha256.cairo

Start with proposal to move alloc from hint to an internal feature of the VM

Break up the vm folder into smaller ones with less files

WebAssembly does not protect against problems inside the sandbox. If you have C++ code that executed undefined behaviour, it can do any possible thing it likes inside that sandbox, poking the interface to the host in any possible way, but the full C++ UB experience does not transfer to the embedder. In that way it can be thought of like a mini-process in your process, or as a container for a library.

• https://www.oreilly.com/library/view/webassembly-the-definitive/9781492089834/ch04.html
• https://petermalmgren.com/serverside-wasm-data/
• https://youtu.be/glL__xjviro
• https://news.ycombinator.com/item?id=24216764
• https://mvolkmann.github.io/blog/webassembly/?v=1.0.19
• https://stackoverflow.com/questions/69789570/webassembly-thread-safety-and-c-c-local-variables
• https://stackoverflow.com/questions/64763007/why-is-webassembly-safe-and-what-is-linear-memory-model
• https://mvolkmann.github.io/blog/webassembly/?v=1.0.19
• https://wasmbyexample.dev/examples/webassembly-linear-memory/webassembly-linear-memory.rust.en-us.html
• https://hacks.mozilla.org/2019/08/webassembly-interface-types/