Skip to content

A compiler to convert Cairo's intermediate representation "Sierra" code to MLIR.

License

Notifications You must be signed in to change notification settings

Gerson2102/cairo_native

 
 

Repository files navigation

⚡ Cairo Native ⚡

A compiler to convert Cairo's intermediate representation "Sierra" code
to machine code via MLIR and LLVM.

Report Bug · Request Feature

Telegram Chat rust codecov license pr-welcome

To get started on how to setup and run cairo-native check the getting started section.

To read more in-depth documentation, visit this page.

⚠️ Disclaimer

🚧 cairo-native is still being built therefore API breaking changes might happen often so use it at your own risk. 🚧

For versions under 1.0 cargo doesn't comply with semver, so we advise to pin the version the version you use. This can be done by adding cairo-native = "0.1.0" to your Cargo.toml

Implemented Library Functions

Cairo Native works by leveraging the intermediate representation of Cairo called Sierra. Sierra uses a list of builtin functions that implement the language functionality, those are called library functions, short: libfuncs. Basically every statement in a sierra program is a call to a libfunc, thus they are the core of Cairo Native progress towards feature parity.

This is a list of the current progress implementing each libfunc.

Implemented libfuncs (click to open)
  1. alloc_local
  2. array_append
  3. array_get
  4. array_len
  5. array_new
  6. array_pop_front_consume
  7. array_pop_front
  8. array_slice
  9. array_snapshot_pop_back
  10. array_snapshot_pop_front
  11. bitwise
  12. bool_and_impl
  13. bool_not_impl
  14. bool_or_impl
  15. bool_to_felt252
  16. bool_xor_impl
  17. box_forward_snapshot
  18. branch_align
  19. bytes31_const
  20. bytes31_to_felt252
  21. bytes31_try_from_felt252
  22. call_contract_syscall (StarkNet)
  23. class_hash_to_felt252 (StarkNet)
  24. class_hash_try_from_felt252 (StarkNet)
  25. const_as_box
  26. contract_address_const (StarkNet)
  27. contract_address_to_felt252 (StarkNet)
  28. contract_address_try_from_felt252 (StarkNet)
  29. deploy_syscall (StarkNet)
  30. disable_ap_tracking
  31. downcast
  32. drop (3)
  33. dup (3)
  34. ec_neg
  35. ec_point_from_x_nz
  36. ec_point_is_zero
  37. ec_point_try_new_nz
  38. ec_point_unwrap
  39. ec_point_zero
  40. ec_state_add_mul
  41. ec_state_add
  42. ec_state_init
  43. ec_state_try_finalize_nz
  44. emit_event_syscall (StarkNet)
  45. enable_ap_tracking
  46. enum_from_bounded_int
  47. enum_init
  48. enum_match
  49. enum_snapshot_match
  50. felt252_add_const (4)
  51. felt252_add
  52. felt252_const
  53. felt252_dict_entry_finalize
  54. felt252_dict_entry_get
  55. felt252_dict_new
  56. felt252_dict_squash
  57. felt252_div_const (4)
  58. felt252_div (4)
  59. felt252_is_zero
  60. felt252_mul_const (4)
  61. felt252_mul
  62. felt252_sub_const (4)
  63. felt252_sub
  64. finalize_locals
  65. function_call
  66. get_available_gas
  67. get_block_hash_syscall (StarkNet)
  68. get_builtin_costs (5)
  69. get_execution_info_syscall (StarkNet)
  70. hades_permutation
  71. i128_diff
  72. i16_diff
  73. i32_diff
  74. i64_diff
  75. i8_diff
  76. into_box (2)
  77. jump
  78. keccak_syscall (StarkNet)
  79. library_call_syscall (StarkNet)
  80. match_nullable
  81. null
  82. nullable_forward_snapshot
  83. nullable_from_box
  84. pedersen
  85. print
  86. rename
  87. replace_class_syscall (StarkNet)
  88. revoke_ap_tracking
  89. secp256k1_add_syscall (StarkNet)
  90. secp256k1_get_point_from_x_syscall (StarkNet)
  91. secp256k1_get_xy_syscall (StarkNet)
  92. secp256k1_mul_syscall (StarkNet)
  93. secp256k1_new_syscall (StarkNet)
  94. secp256r1_add_syscall (StarkNet)
  95. secp256r1_get_point_from_x_syscall (StarkNet)
  96. secp256r1_get_xy_syscall (StarkNet)
  97. secp256r1_mul_syscall (StarkNet)
  98. secp256r1_new_syscall (StarkNet)
  99. send_message_to_l1_syscall (StarkNet)
  100. snapshot_take (1)
  101. span_from_tuple
  102. storage_address_from_base_and_offset (StarkNet)
  103. storage_address_from_base (StarkNet)
  104. storage_address_to_felt252 (StarkNet)
  105. storage_address_try_from_felt252 (StarkNet)
  106. storage_base_address_const (StarkNet)
  107. storage_base_address_from_felt252 (StarkNet)
  108. storage_read_syscall (StarkNet)
  109. storage_write_syscall (StarkNet)
  110. store_local
  111. store_temp
  112. struct_construct
  113. struct_deconstruct
  114. struct_snapshot_deconstruct
  115. u128_byte_reverse
  116. u128_const
  117. u128_eq
  118. u128_guarantee_mul
  119. u128_is_zero
  120. u128_mul_guarantee_verify
  121. u128_overflowing_add
  122. u128_overflowing_sub
  123. u128_safe_divmod
  124. u128_sqrt
  125. u128_to_felt252
  126. u128s_from_felt252
  127. u16_const
  128. u16_eq
  129. u16_is_zero
  130. u16_overflowing_add
  131. u16_overflowing_sub
  132. u16_safe_divmod
  133. u16_sqrt
  134. u16_to_felt252
  135. u16_try_from_felt252
  136. u16_wide_mul
  137. u256_is_zero
  138. u256_safe_divmod
  139. u256_sqrt
  140. u32_const
  141. u32_eq
  142. u32_is_zero
  143. u32_overflowing_add
  144. u32_overflowing_sub
  145. u32_safe_divmod
  146. u32_sqrt
  147. u32_to_felt252
  148. u32_try_from_felt252
  149. u32_wide_mul
  150. u64_const
  151. u64_eq
  152. u64_is_zero
  153. u64_overflowing_add
  154. u64_overflowing_sub
  155. u64_safe_divmod
  156. u64_sqrt
  157. u64_to_felt252
  158. u64_try_from_felt252
  159. u64_wide_mul
  160. u8_const
  161. u8_eq
  162. u8_is_zero
  163. u8_overflowing_add
  164. u8_overflowing_sub
  165. u8_safe_divmod
  166. u8_sqrt
  167. u8_to_felt252
  168. u8_try_from_felt252
  169. u8_wide_mul
  170. unbox (2)
  171. unwrap_non_zero
  172. upcast
  173. withdraw_gas_all (5)
  174. withdraw_gas (5)
Not yet implemented libfuncs (click to open) 1. coupon
Not yet implemented libfuncs (testing category only, click to open) Testing libfuncs:
  1. pop_log (StarkNet, testing)
  2. redeposit_gas
  3. set_account_contract_address (StarkNet, testing)
  4. set_block_number (StarkNet, testing)
  5. set_block_timestamp (StarkNet, testing)
  6. set_caller_address (StarkNet, testing)
  7. set_chain_id (StarkNet, testing)
  8. set_contract_address (StarkNet, testing)
  9. set_max_fee (StarkNet, testing)
  10. set_nonce (StarkNet, testing)
  11. set_sequencer_address (StarkNet, testing)
  12. set_signature (StarkNet, testing)
  13. set_transaction_hash (StarkNet, testing)
  14. set_version (StarkNet, testing)

Footnotes on the libfuncs list:

  1. It is implemented but we're not handling potential issues like lifetimes yet.
  2. It is implemented but we're still debating whether it should be a Rust-like Box<T> or if it's fine treating it like another variable.
  3. It is implemented but side-effects are not yet handled (ex. array cloning/dropping).
  4. Not supported by the Cairo to Sierra compiler.
  5. Implemented with a dummy. It doesn't do anything yet.

Getting Started

Dependencies

  • Linux or macOS (aarch64 included) only for now
  • LLVM 18 with MLIR: On debian you can use apt.llvm.org, on macOS you can use brew
  • Rust 1.78.0 or later, since we make use of the u128 abi change.
  • Git

Setup

This step applies to all operating systems.

Run the following make target to install the dependencies (both Linux and macOS):

make deps

Linux

Since Linux distributions change widely, you need to install LLVM 18 via your package manager, compile it or check if the current release has a Linux binary.

If you are on Debian/Ubuntu, check out the repository https://apt.llvm.org/ Then you can install with:

sudo apt-get install llvm-18 llvm-18-dev llvm-18-runtime clang-18 clang-tools-18 lld-18 libpolly-18-dev libmlir-18-dev mlir-18-tools

If you decide to build from source, here are some indications:

Install LLVM from source instructions
# Go to https://github.com/llvm/llvm-project/releases
# Download the latest LLVM 18 release:
# The blob to download is called llvm-project-18.x.x.src.tar.xz

# For example
wget https://github.com/llvm/llvm-project/releases/download/llvmorg-18.1.4/llvm-project-18.1.4.src.tar.xz
tar xf llvm-project-18.1.4.src.tar.xz

cd llvm-project-18.1.4.src.tar
mkdir build
cd build

# The following cmake command configures the build to be installed to /opt/llvm-18
cmake -G Ninja ../llvm \
   -DLLVM_ENABLE_PROJECTS="mlir;clang;clang-tools-extra;lld;polly" \
   -DLLVM_BUILD_EXAMPLES=OFF \
   -DLLVM_TARGETS_TO_BUILD="Native" \
   -DCMAKE_INSTALL_PREFIX=/opt/llvm-18 \
   -DCMAKE_BUILD_TYPE=RelWithDebInfo \
   -DLLVM_PARALLEL_LINK_JOBS=4 \
   -DLLVM_ENABLE_BINDINGS=OFF \
   -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DLLVM_ENABLE_LLD=ON \
   -DLLVM_ENABLE_ASSERTIONS=OFF

ninja install

Setup a environment variable called MLIR_SYS_180_PREFIX, LLVM_SYS_180_PREFIX and TABLEGEN_180_PREFIX pointing to the llvm directory:

# For Debian/Ubuntu using the repository, the path will be /usr/lib/llvm-18
export MLIR_SYS_180_PREFIX=/usr/lib/llvm-18
export LLVM_SYS_180_PREFIX=/usr/lib/llvm-18
export TABLEGEN_180_PREFIX=/usr/lib/llvm-18

Run the deps target to install the other dependencies such as the cairo compiler (for tests, benchmarks).

make deps

MacOS

The makefile deps target (which you should have ran before) installs LLVM 18 with brew for you, afterwards you need to execute the env-macos.sh script to setup the needed environment variables.

source env-macos.sh

Make commands:

Running make by itself will list available targets.

  • Install the necessary dependencies (on Linux, you need to get LLVM 18 manually):
make deps
  • Build a release version:
make build

Or with your native CPU Architecture for even more performance (usually):

make build-native
  • Install the cairo-native-dump and cairo-native-run commands:
make install
  • Build a optimized development version:
make build-dev
  • View and open the docs:
make doc-open
  • Run the tests:
make test
  • Generate coverage:
make coverage
  • Run clippy and format checks:
make check
  • Compile the runtime library used for ahead of time compilation:
make runtime

Command Line Interface

cairo-native-dump:

Usage: cairo-native-dump [OPTIONS] <INPUT>

Arguments:
  <INPUT>

Options:
  -o, --output <OUTPUT>  [default: -]
  -h, --help             Print help

cairo-native-run:

This tool allows to run programs using the JIT engine, like the cairo-run tool, the parameters can only be felt values.

echo '1' | cairo-native-run 'program.cairo' 'program::program::main' --inputs - --outputs -

Usage: cairo-native-run [OPTIONS] <INPUT> <ENTRY_POINT>

Arguments:
  <INPUT>
  <ENTRY_POINT>

Options:
  -i, --inputs <INPUTS>
  -o, --outputs <OUTPUTS>
  -p, --print-outputs
  -h, --help               Print help

API usage example

This is a usage example using the API for an easy Cairo program that requires the least setup to get running. It allows you to compile and execute a program using the JIT.

Example code to run a program:

use starknet_types_core::felt::Felt;
use cairo_native::context::NativeContext;
use cairo_native::executor::NativeExecutor;
use cairo_native::values::JitValue;
use std::path::Path;

fn main() {
    let program_path = Path::new("programs/examples/hello.cairo");
    // Compile the cairo program to sierra.
    let sierra_program = cairo_native::utils::cairo_to_sierra(program_path);

    // Instantiate a Cairo Native MLIR context. This data structure is responsible for the MLIR
    // initialization and compilation of sierra programs into a MLIR module.
    let native_context = NativeContext::new();

    // Compile the sierra program into a MLIR module.
    let native_program = native_context.compile(&sierra_program).unwrap();

    // The parameters of the entry point.
    let params = &[JitValue::Felt252(Felt::from_bytes_be_slice(b"user"))];

    // Find the entry point id by its name.
    let entry_point = "hello::hello::greet";
    let entry_point_id = cairo_native::utils::find_function_id(&sierra_program, entry_point);

    // Instantiate the executor.
    let native_executor = NativeExecutor::new(native_program);

    // Execute the program.
    let result = native_executor
        .execute(entry_point_id, params, None)
        .unwrap();

    println!("Cairo program was compiled and executed successfully.");
    println!("{:?}", result);
}

Example code to run a Starknet contract:

use starknet_types_core::felt::Felt;
use cairo_lang_compiler::CompilerConfig;
use cairo_lang_starknet::contract_class::compile_path;
use cairo_native::context::NativeContext;
use cairo_native::executor::NativeExecutor;
use cairo_native::utils::find_entry_point_by_idx;
use cairo_native::values::JitValue;
use cairo_native::{
    metadata::syscall_handler::SyscallHandlerMeta,
    starknet::{BlockInfo, ExecutionInfo, StarkNetSyscallHandler, SyscallResult, TxInfo, U256},
};
use std::path::Path;

/// To run a starknet contract, we need to use a syscall handler, here we show how to implement one (at the end).
#[derive(Debug)]
struct SyscallHandler;

fn main() {
    let path = Path::new("programs/examples/hello_starknet.cairo");

    let contract = compile_path(
        path,
        None,
        CompilerConfig {
            replace_ids: true,
            ..Default::default()
        },
    )
    .unwrap();

    let entry_point = contract.entry_points_by_type.constructor.get(0).unwrap();
    let sierra_program = contract.extract_sierra_program().unwrap();

    let native_context = NativeContext::new();

    let mut native_program = native_context.compile(&sierra_program).unwrap();
    native_program
        .insert_metadata(SyscallHandlerMeta::new(&mut SyscallHandler))
        .unwrap();

    // Call the echo function from the contract using the generated wrapper.
    let entry_point_fn =
        find_entry_point_by_idx(&sierra_program, entry_point.function_idx).unwrap();

    let fn_id = &entry_point_fn.id;

    let native_executor = NativeExecutor::new(native_program);

    let result = native_executor
        .execute_contract(
            fn_id,
            // The calldata
            &[JitValue::Felt252(Felt::ONE)],
            u64::MAX.into(),
        )
        .expect("failed to execute the given contract");

    println!();
    println!("Cairo program was compiled and executed successfully.");
    println!("{result:#?}");
}

// Implement an example syscall handler.
impl StarkNetSyscallHandler for SyscallHandler {
    fn get_block_hash(
        &mut self,
        block_number: u64,
        _gas: &mut u128,
    ) -> SyscallResult<Felt> {
        println!("Called `get_block_hash({block_number})` from MLIR.");
        Ok(Felt::from_bytes_be_slice(b"get_block_hash ok"))
    }

    fn get_execution_info(
        &mut self,
        _gas: &mut u128,
    ) -> SyscallResult<cairo_native::starknet::ExecutionInfo> {
        println!("Called `get_execution_info()` from MLIR.");
        Ok(ExecutionInfo {
            block_info: BlockInfo {
                block_number: 1234,
                block_timestamp: 2345,
                sequencer_address: 3456.into(),
            },
            tx_info: TxInfo {
                version: 4567.into(),
                account_contract_address: 5678.into(),
                max_fee: 6789,
                signature: vec![1248.into(), 2486.into()],
                transaction_hash: 9876.into(),
                chain_id: 8765.into(),
                nonce: 7654.into(),
            },
            caller_address: 6543.into(),
            contract_address: 5432.into(),
            entry_point_selector: 4321.into(),
        })
    }

    fn deploy(
        &mut self,
        class_hash: Felt,
        contract_address_salt: Felt,
        calldata: &[Felt],
        deploy_from_zero: bool,
        _gas: &mut u128,
    ) -> SyscallResult<(Felt, Vec<Felt>)> {
        println!("Called `deploy({class_hash}, {contract_address_salt}, {calldata:?}, {deploy_from_zero})` from MLIR.");
        Ok((
            class_hash + contract_address_salt,
            calldata.iter().map(|x| x + &Felt::ONE).collect(),
        ))
    }

    fn replace_class(
        &mut self,
        class_hash: Felt,
        _gas: &mut u128,
    ) -> SyscallResult<()> {
        println!("Called `replace_class({class_hash})` from MLIR.");
        Ok(())
    }

    fn library_call(
        &mut self,
        class_hash: Felt,
        function_selector: Felt,
        calldata: &[Felt],
        _gas: &mut u128,
    ) -> SyscallResult<Vec<Felt>> {
        println!(
            "Called `library_call({class_hash}, {function_selector}, {calldata:?})` from MLIR."
        );
        Ok(calldata.iter().map(|x| x * Felt::from(3)).collect())
    }

    fn call_contract(
        &mut self,
        address: Felt,
        entry_point_selector: Felt,
        calldata: &[Felt],
        _gas: &mut u128,
    ) -> SyscallResult<Vec<Felt>> {
        println!(
            "Called `call_contract({address}, {entry_point_selector}, {calldata:?})` from MLIR."
        );
        Ok(calldata.iter().map(|x| x * Felt::from(3)).collect())
    }

    fn storage_read(
        &mut self,
        address_domain: u32,
        address: Felt,
        _gas: &mut u128,
    ) -> SyscallResult<Felt> {
        println!("Called `storage_read({address_domain}, {address})` from MLIR.");
        Ok(address * Felt::from(3))
    }

    fn storage_write(
        &mut self,
        address_domain: u32,
        address: Felt,
        value: Felt,
        _gas: &mut u128,
    ) -> SyscallResult<()> {
        println!("Called `storage_write({address_domain}, {address}, {value})` from MLIR.");
        Ok(())
    }

    fn emit_event(
        &mut self,
        keys: &[Felt],
        data: &[Felt],
        _gas: &mut u128,
    ) -> SyscallResult<()> {
        println!("Called `emit_event({keys:?}, {data:?})` from MLIR.");
        Ok(())
    }

    fn send_message_to_l1(
        &mut self,
        to_address: Felt,
        payload: &[Felt],
        _gas: &mut u128,
    ) -> SyscallResult<()> {
        println!("Called `send_message_to_l1({to_address}, {payload:?})` from MLIR.");
        Ok(())
    }

    fn keccak(
        &mut self,
        input: &[u64],
        _gas: &mut u128,
    ) -> SyscallResult<cairo_native::starknet::U256> {
        println!("Called `keccak({input:?})` from MLIR.");
        Ok(U256(Felt::from(1234567890).to_le_bytes()))
    }

    /*
    ... more code here, check out the full example in examples/starknet.rsd
    */
}

For more examples, check out the examples/ directory.

Benchmarking

Requirements

You need to setup some environment variables:

$MLIR_SYS_180_PREFIX=/path/to/llvm18  # Required for non-standard LLVM install locations.
$LLVM_SYS_180_PREFIX=/path/to/llvm18  # Required for non-standard LLVM install locations.
$TABLEGEN_180_PREFIX=/path/to/llvm18  # Required for non-standard LLVM install locations.
make bench

The bench target will run the ./scripts/bench-hyperfine.sh script. This script runs hyperfine commands to compare the execution time of programs in the ./programs/benches/ folder. Each program is compiled and executed via the execution engine with the cairo-native-run command and via the cairo-vm with the cairo-run command provided by the cairo codebase. The cairo-run command should be available in the $PATH and ideally compiled with cargo build --release. If you want the benchmarks to run using a specific build, or the cairo-run commands conflicts with something (e.g. the cairo-svg package binaries in macos) then the command to run cairo-run with a full path can be specified with the $CAIRO_RUN environment variable.

From MLIR to native binary

# to mlir with llvm dialect
sierra2mlir program.sierra -o program.mlir

# translate all dialects to the llvm dialect
"$MLIR_SYS_180_PREFIX/bin/mlir-opt" \
        --canonicalize \
        --convert-scf-to-cf \
        --canonicalize \
        --cse \
        --expand-strided-metadata \
        --finalize-memref-to-llvm \
        --convert-func-to-llvm \
        --convert-index-to-llvm \
        --reconcile-unrealized-casts \
        "program.mlir" \
        -o "program-llvm.mlir"

# translate mlir to llvm-ir
"$MLIR_SYS_180_PREFIX"/bin/mlir-translate --mlir-to-llvmir program-llvm.mlir -o program.ll

# compile natively
"$MLIR_SYS_180_PREFIX"/bin/clang program.ll -Wno-override-module \
    -L "$MLIR_SYS_180_PREFIX"/lib -L"./target/release/" \
    -lsierra2mlir_utils -lmlir_c_runner_utils \
    -Wl,-rpath "$MLIR_SYS_180_PREFIX"/lib \
    -Wl,-rpath ./target/release/ \
    -o program

./program

cairo-native-test cli tool

This tool mimics the cairo-test tool and is identical to it, the only feature it doesn't have is the profiler.

You can download it on our releases page.

$ cairo-native-test --help
Compiles a Cairo project and runs all the functions marked as `#[test]`.
Exits with 1 if the compilation or run fails, otherwise 0.

Usage: cairo-native-test [OPTIONS] <PATH>

Arguments:
  <PATH>  The Cairo project path to compile and run its tests

Options:
  -s, --single-file            Whether path is a single file
      --allow-warnings         Allows the compilation to succeed with warnings
  -f, --filter <FILTER>        The filter for the tests, running only tests containing the filter string [default: ]
      --include-ignored        Should we run ignored tests as well
      --ignored                Should we run only the ignored tests
      --starknet               Should we add the starknet plugin to run the tests
      --run-mode <RUN_MODE>    Run with JIT or AOT (compiled) [default: jit] [possible values: aot, jit]
  -O, --opt-level <OPT_LEVEL>  Optimization level, Valid: 0, 1, 2, 3. Values higher than 3 are considered as 3 [default: 0]
  -h, --help                   Print help
  -V, --version                Print version

For single files, you can use the -s, --single-file option.

For a project, it needs to have a cairo_project.toml specifying the crate_roots. You can find an example under the cairo-tests/ folder, which is a cairo project that works with this tool.

cairo-native-test -s myfile.cairo

cairo-native-test ./cairo-tests/

This will run all the tests (functions marked with the #[test] attribute).

Debugging Tips

Useful environment variables

These 2 env vars will dump the generated MLIR code from any compilation on the current working directory as:

  • dump.mlir: The MLIR code after passes without locations.
  • dump-debug.mlir: The MLIR code after passes with locations.
  • dump-prepass.mlir: The MLIR code before without locations.
  • dump-prepass-debug.mlir: The MLIR code before passes with locations.

Do note that the MLIR with locations is in pretty form and thus not suitable to pass to mlir-opt.

export NATIVE_DEBUG_DUMP_PREPASS=1
export NATIVE_DEBUG_DUMP=1

Enable logging to see the compilation process:

export RUST_LOG="cairo_native=trace"

Other tips:

  • Try to find the minimal program to reproduce an issue, the more isolated the easier to test.
  • Use the debug_utils print utilities, more info here:
#[cfg(feature = "with-debug-utils")]
{
    metadata.get_mut::<DebugUtils>()
        .unwrap()
        .print_pointer(context, helper, entry, ptr, location)?;
}

About

A compiler to convert Cairo's intermediate representation "Sierra" code to MLIR.

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages

  • Rust 84.5%
  • Cairo 14.4%
  • Assembly 0.3%
  • Shell 0.3%
  • Makefile 0.3%
  • C 0.1%
  • Other 0.1%