Wasm with Cairo 1

.github/workflows/rust.yml

@@ -824,7 +824,24 @@ jobs:
         cairo-compile cairo_programs/array_sum.cairo --no_debug_info --output cairo_programs/array_sum.json
         cd examples/wasm-demo
         wasm-pack build --target=web
-
+
+  wasm-demo-cairo1:
+    name: Build the wasm demo cairo1
+    runs-on: ubuntu-22.04
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+
+    - name: Install cairo-lang and deps
+      run: |
+        npm install -g wasm-pack
+    - name: Build wasm-demo-cairo1
+      run: |
+        cd examples/wasm-demo-cairo1
+        wasm-pack build --target=web
+
   compare-factorial-outputs-all-layouts:
     name: Compare factorial outputs for all layouts
     needs: [ build-programs, build-release ]

CHANGELOG.md

@@ -200,6 +200,8 @@
 * chore: bump `cairo-lang-` dependencies to 2.8.0 [#1833](https://github.com/lambdaclass/cairo-vm/pull/1833/files)
   * chore: update Rust required version to 1.80.0
 
+* chore: make cairo 1.0 compatible with wasm [#1830](https://github.com/lambdaclass/cairo-vm/pull/1830)
+
 * fix: Added the following VM fixes: [#1820](https://github.com/lambdaclass/cairo-vm/pull/1820)
   * Fix zero segment location.
   * Fix has_zero_segment naming.

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "vm",
     "hint_accountant",
     "examples/wasm-demo",
+    "examples/wasm-demo-cairo1",
     "cairo1-run",
     "cairo-vm-tracer",
     "examples/hyper_threading",
@@ -25,6 +26,7 @@ keywords = ["starknet", "cairo", "vm", "wasm", "no_std"]
 
 [workspace.dependencies]
 cairo-vm = { path = "./vm", version = "3.0.0-rc.1", default-features = false }
+cairo1-run = { path = "./cairo1-run", version = "3.0.0-rc.1", default-features = false }
 cairo-vm-tracer = { path = "./cairo-vm-tracer", version = "3.0.0-rc.1", default-features = false }
 mimalloc = { version = "0.1.37", default-features = false }
 num-bigint = { version = "0.4", default-features = false, features = [
@@ -89,6 +91,9 @@ lto = "fat"
 # Tell `rustc` to optimize for small code size.
 opt-level = "s"
 
+[profile.release.package.wasm-demo-cairo1]
+opt-level = "s"
+
 [profile.test.package.proptest]
 opt-level = 3
 

cairo1-run/Cargo.toml

@@ -9,7 +9,8 @@ keywords.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cairo-vm = { workspace = true, features = ["std", "cairo-1-hints", "clap"] }
+cairo-vm = {workspace = true, features = ["cairo-1-hints", "clap"]}
+
 serde_json = { workspace = true }
 
 cairo-lang-sierra-type-size = { version = "2.12.0-dev.0", default-features = false }
@@ -29,3 +30,9 @@ num-bigint.workspace = true
 
 [features]
 mod_builtin = ["cairo-vm/mod_builtin"]
+cli = ["dep:thiserror", "cairo-vm/std"]
+
+[[bin]]
+name = "cairo1-run"
+path = "./src/main.rs"
+required-features = ["cli"]

cairo1-run/Makefile

@@ -3,10 +3,10 @@
 CAIRO_1_FOLDER=../cairo_programs/cairo-1-programs
 
 $(CAIRO_1_FOLDER)/%.trace: $(CAIRO_1_FOLDER)/%.cairo
-	cargo run --release -F mod_builtin $< --trace_file $@ --layout all_cairo
+	cargo run --release --features cli -F mod_builtin $< --trace_file $@ --layout all_cairo
 
 $(CAIRO_1_FOLDER)/%.memory: $(CAIRO_1_FOLDER)/%.cairo
-	cargo run --release -F mod_builtin $< --memory_file $@ --layout all_cairo
+	cargo run --release --features cli -F mod_builtin $< --memory_file $@ --layout all_cairo
 
 CAIRO_1_PROGRAMS=$(wildcard ../cairo_programs/cairo-1-programs/*.cairo)
 TRACES:=$(patsubst $(CAIRO_1_FOLDER)/%.cairo, $(CAIRO_1_FOLDER)/%.trace, $(CAIRO_1_PROGRAMS))
@@ -20,7 +20,7 @@ deps:
 run: $(TRACES) $(MEMORY)
 
 test:
-	cargo test
+	cargo test --features cli
 
 clean:
 	rm -rf corelib

cairo1-run/README.md

@@ -8,6 +8,7 @@ To install the required dependencies(cairo corelib) run
 
 ```bash
 make deps
+make deps
 ```
 
 Now that you have the dependencies necessary to run the tests, you can run:
@@ -16,18 +17,17 @@ Now that you have the dependencies necessary to run the tests, you can run:
 make test
 ```
 
-To execute a Cairo 1 program (either as Cairo 1 source file or Sierra)
+To execute a Cairo 1 program (either as Cairo 1 source file or Sierra). Make sure the `cli` feature is active in order to use `cairo1-run` as a binary.
 
 ```bash
-cargo run ../cairo_programs/cairo-1-programs/fibonacci.cairo
+cargo run --features cli ../cairo_programs/cairo-1-programs/fibonacci.cairo
 ```
 
 Arguments to generate the trace and memory files
 
 ```bash
-cargo run ../cairo_programs/cairo-1-programs/fibonacci.cairo --trace_file ../cairo_programs/cairo-1-programs/fibonacci.trace --memory_file ../cairo_programs/cairo-1-programs/fibonacci.memory
+cargo run --features cli ../cairo_programs/cairo-1-programs/fibonacci.cairo --trace_file ../cairo_programs/cairo-1-programs/fibonacci.trace --memory_file ../cairo_programs/cairo-1-programs/fibonacci.memory
 ```
-
 To pass arguments to `main`
 
 * Separate arguments with a whitespace inbetween
@@ -37,7 +37,7 @@ Example:
 
 ```bash
 
-cargo run ../cairo_programs/cairo-1-programs/with_input/array_input_sum.cairo --layout all_cairo --args '2 [1 2 3 4] 0 [9 8]'
+cargo run --features cli ../cairo_programs/cairo-1-programs/with_input/array_input_sum.cairo --layout all_cairo --args '2 [1 2 3 4] 0 [9 8]'
 
 ```
 
@@ -90,7 +90,7 @@ Then run the compiled project's sierra file located at `project_name/target/proj
 
 Example:
 ```bash
-  cargo run path-to-project/target/project_name.sierra.json
+  cargo run --features cli path-to-project/target/project_name.sierra.json
 ```
 
 # Known bugs & issues

cairo1-run/src/cairo_run.rs

@@ -38,6 +38,7 @@ use cairo_vm::{
     hint_processor::cairo_1_hint_processor::hint_processor::Cairo1HintProcessor,
     math_utils::signed_felt,
     serde::deserialize_program::{ApTracking, FlowTrackingData, HintParams, ReferenceManager},
+    stdlib::{cmp, collections::HashMap, iter::Peekable},
     types::{
         builtin_name::BuiltinName, layout::CairoLayoutParams, layout_name::LayoutName,
         program::Program, relocatable::MaybeRelocatable,
@@ -52,7 +53,6 @@ use cairo_vm::{
 use itertools::{chain, Itertools};
 use num_bigint::{BigInt, Sign};
 use num_traits::{cast::ToPrimitive, Zero};
-use std::{collections::HashMap, iter::Peekable};
 
 /// Representation of a cairo argument
 /// Can consist of a single Felt or an array of Felts
@@ -1415,7 +1415,7 @@ fn serialize_output_inner<'a>(
             let mut max_variant_size = 0;
             for variant in &info.variants {
                 let variant_size = type_sizes.get(variant).unwrap();
-                max_variant_size = std::cmp::max(max_variant_size, *variant_size)
+                max_variant_size = cmp::max(max_variant_size, *variant_size)
             }
             for _ in 0..max_variant_size - type_sizes.get(variant_type_id).unwrap() {
                 // Remove padding

cairo1-run/src/error.rs

@@ -10,12 +10,16 @@ use cairo_vm::{
     },
     Felt252,
 };
+#[cfg(feature = "cli")]
 use thiserror::Error;
+#[cfg(not(feature = "cli"))]
+use thiserror_no_std::Error;
 
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("Invalid arguments")]
     Cli(#[from] clap::Error),
+    #[cfg(feature = "cli")]
     #[error("Failed to interact with the file system")]
     IO(#[from] std::io::Error),
     #[error(transparent)]

examples/wasm-demo-cairo1/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "wasm-demo-cairo1"
+description = "A demo using cairo-vm in a WASM environment"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+readme = "README.md"
+keywords.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = ["console_error_panic_hook"]
+
+[dependencies]
+serde_json.workspace = true
+wasm-bindgen = "0.2.87"
+cairo-lang-sierra = { workspace = true }
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+# code size when deploying.
+console_error_panic_hook = { version = "0.1.6", optional = true }
+
+cairo-vm = { workspace = true }
+cairo1-run = { workspace = true }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3.34"

examples/wasm-demo-cairo1/README.md

@@ -0,0 +1,58 @@
+# Demo of `cairo-vm` on WebAssembly
+
+While cairo-vm is compatible with WebAssembly, it doesn't implement any bindings to it.
+Instead, create a new WebAssembly crate with cairo-vm and cairo1-run as dependencies and implement the required functionality there.
+
+Since mimalloc is not automatically compilable to WebAssembly, the cairo-vm dependency should disable the default features, which will in turn disable mimalloc.
+
+A working example is provided in this repository.
+
+## Dependencies
+
+To compile and run the example you need:
+
+- an either Cairo 1 or Cairo 2 compiler
+- the _wasm-pack_ crate
+- some HTTP server (for example: the `live-server` npm module)
+
+> **Note**
+> The first two dependencies can be installed via the repository's installation script (see ["Installation script"](../../README.md#installation-script))
+
+## Building
+
+To build the example, first compile your Cairo 1 / 2 program:
+
+Cairo 1
+
+```sh
+../../cairo1/bin/cairo-compile -r ./bitwise.cairo  bitwise.sierra
+```
+
+Cairo 2
+
+```sh
+../../cairo2/bin/cairo-compile -r ./bitwise.cairo  bitwise.sierra
+```
+
+> It's important to use the `-r` flag. If not, the `main` function won't be recognized.
+
+And then the WebAssembly package:
+
+```sh
+wasm-pack build --target=web
+```
+
+This will generate a javascript module that is directly loadable by the browser.
+
+## Running
+
+To run the example webpage, you need to run an HTTP server.
+For example, using the _live-server_ npm module:
+
+```sh
+# while in <repo>/examples/wasm-demo-cairo1
+npx live-server
+```
+
+> **Warning**
+> Trying to run `index.html` directly (i.e. URL starts with `file://`) will result in a CORS error.

examples/wasm-demo-cairo1/bitwise.cairo

@@ -0,0 +1,12 @@
+fn main() -> u128 {
+    let a = 1234_u128;
+    let b = 5678_u128;
+
+    let c0 = a & b;
+    let c1 = a ^ b;
+    let c2 = a | b;
+
+    let c3 = c0 + c1 + c2;
+
+    c3
+}