Also we should investigate the use of entry point args.

This should be a separate workflow running on PRs that blocks merge.
It's needed because once a PR in cairo-rs is merged the branch is deleted and the ref may become stale and break main.
It needs to be separate so temporarily pointing to a dev branch is allowed and doesn't give false negatives when it comes to just tests.

Cairo-rs possesses a segment manager that is tasked with generating new memory segments as needed.

This manager has a method called write_arg, which can take a pointer and a vector of bigints to write said vector into memory, at the position indicated by the pointer.

For the cairo-rs-py crate, we want to overwrite this method to be able to take any iterable argument. Each element should also be able to be an iterable or a bigint as well.

The memory should have bigints and pointers to segments whenever an iterable element was encountered. The segments are assigned as needed each time we find an iterable and the parent of that iterable will have a pointer to that new segment.

As an example, if write_arg is called with a mixed list args at the position (0, 0), the segments should look like this:

As we start stepping through each element of the input array, we check if that element is an iterable or not. If it is, we'll generate a new segment, we point to its base from the segment we started form and dump all the values into the new segment.

A few references from the cairo python VM and the rust VM:

• cairo-rs write_arg and auxiliary functions
• cairo-lang write_arg implementation

While for the most part we should have no Python deps, at the very least we use them for testing. The proper place to keep them and to specify the versions used is in such file.

Add instructions on how to import and run the VM from Python to README & Makefile

In cairo-rs, ExecScopesProxy will be removed and this should be modified in cairo-rs-py.

This os_context is a list of MaybeRelocatable values that is passed as an argument to run_from_entrypoint (see #30) and it is defined here.

Implement macros for initialization of VM for tests (memory, run context, etc)

cairo-rs-py does not throw an InvalidStopPointer error

We (@FuzzingLabs) found that cairo-rs-py does not throw an InvalidStopPointer error while processing the following file.

Result using cairo-rs

Invalid stop pointer for output 
Error: Runner(InvalidStopPointer("output"))

Result using cairo-lang

Error: Invalid stop pointer for output. Expected: 2:0, found: 4:0

Result using cairo-rs-py

Program Output: 

Expected Behavior

cairo-rs-py should throw an error as cairo-rs and cairo-lang

Your Environment

• 8dba86dbec935fa04a255e2edf3d5d184950fa22
• cargo 1.67.0-nightly (ba607b23d 2022-11-22)
• Ubuntu 22.04

Steps to reproduce

Download:
crash.zip

Using cairo-rs

./target/release/cairo-rs-run cairo_programs/crash2.json --layout all

Using cairo-lang

cairo-run --program crash2.json --layout all

Using cairo-rs-py

import cairo_rs_py
with open("crash2.json") as file:
        return cairo_rs_py.CairoRunner(file.read(), "main", "all", False)

#58 implements support for custom types in references for hints. It's currently only using integration tests to validate the functionality. It would be desirable to also unit test it.

Inside a hint, it may be necessary to assign a struct inside another struct. Consider the example:

struct Foo {
    a: Bar
}

struct Bar {
    b: felt
}

A hint may want to assign field a from Foo like so:

ids.foo.a = ids.bar

Where foo and bar are instances of the structs Foo and Bar respectively.

This is not supported yet, and if necessary, support for this should be added.

Keep in mind that we are going to pass the path to the contract but only temporarily. In the future, the bytecode would be retrieved from the contract address.

See https://github.com/lambdaclass/cairo-rs-py/blob/7c915272779f4b7d94bf94c771624843a8d44bb7/src/ids.rs#L144

Once the function is imported from cairo-rs it should be deleted in this repo.

We should implement ECDSA in rust and also check if any other built-in is missing.

As the number of arguments to cairo_run_py is getting larger, we should consider creating a struct that will hold these arguments and pass that to cairo_run_py.

To reduce some boilerplate code, rewrite the fn to_py_error as a From trait for PyErr and VirtualMachineError.
Then we should replace all the .map_err(to_py_error) with .into().

Fix code to address clippy warnings