added e2e tests from cairo repo

Author: TomerStarkware

.github/workflows/starknet-blocks.yml

@@ -8,7 +8,6 @@ on:
 
 jobs:
   run-blocks:
-    if: false
     name: Run Blocks
     runs-on: ubuntu-latest
     env:
@@ -33,7 +32,7 @@ jobs:
         with:
           repository: starkware-libs/starknet-replay
           path: starknet-replay
-          ref: 5e75e33d67de77fe68aba06e05571175c0976733
+          ref: 4b896e523bd33da66b95c8b2afdb7423785e99d4
 
       # We need native to use the linux deps ci action
       - name: Checkout Native

.gitignore

@@ -34,11 +34,13 @@ cairo-*.tar
 
 *.ipynb
 cairo-native-stress-logs.jsonl
- 
+
 .DS_Store
 bench_starknet_compilation_data
 cairo
 
+test_data/e2e_sierra/
+test_data/e2e_libfuncs_raw/
 test_data_artifacts/programs
 test_data_artifacts/contracts
 test_data_artifacts/tests

Makefile

@@ -191,6 +191,12 @@ install-scarb-macos:
 .PHONY: pull-external-projects
 pull-external-projects:
 	python3 ./scripts/pull_external_projects.py v${CAIRO_2_VERSION}
+	python3 ./scripts/extract_e2e_sierra.py
+
+.PHONY: extract-e2e-sierra
+extract-e2e-sierra:
+	python3 ./scripts/extract_e2e_sierra.py
+
 
 .PHONY: compile-test-data
 compile-test-data:

scripts/extract_e2e_sierra.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+Extract sierra_code sections from cairo e2e test data files.
+
+Input:  test_data/e2e_libfuncs_raw/  (files in //! > format)
+Output: test_data/e2e_sierra/         (individual .sierra files)
+"""
+
+import os
+import re
+import shutil
+import sys
+
+SRC_DIR = "test_data/e2e_libfuncs_raw"
+DST_DIR = "test_data/e2e_sierra"
+
+
+def sanitize_name(name):
+    """Convert test name to a safe filename."""
+    return re.sub(r"[^\w\-]", "_", name.strip()).strip("_")
+
+
+def parse_test_cases(text):
+    """Parse //! > format into list of test-case dicts mapping section_key -> content."""
+    cases = re.split(r"^//! > =+\s*$", text, flags=re.MULTILINE)
+    results = []
+    for case in cases:
+        sections = {}
+        section_order = []
+        current_section = None
+        lines = []
+        for line in case.splitlines():
+            m = re.match(r"^//! > (.+)$", line)
+            if m:
+                if current_section is not None:
+                    sections[current_section] = "\n".join(lines).strip()
+                current_section = m.group(1).strip()
+                section_order.append(current_section)
+                lines = []
+            else:
+                lines.append(line)
+        if current_section is not None:
+            sections[current_section] = "\n".join(lines).strip()
+        if sections:
+            sections["_order"] = section_order
+            results.append(sections)
+    return results
+
+
+def main():
+    if not os.path.isdir(SRC_DIR):
+        print(
+            f"Source directory {SRC_DIR} not found. "
+            "Run 'make pull-external-projects' first."
+        )
+        sys.exit(1)
+
+    shutil.rmtree(DST_DIR, ignore_errors=True)
+
+    count = 0
+    for dirpath, _, filenames in sorted(os.walk(SRC_DIR)):
+        for filename in sorted(filenames):
+            filepath = os.path.join(dirpath, filename)
+
+            with open(filepath, "r") as f:
+                content = f.read()
+
+            # Preserve subdirectory structure (e.g. starknet/syscalls)
+            rel_dir = os.path.relpath(dirpath, SRC_DIR)
+            test_cases = parse_test_cases(content)
+            for case in test_cases:
+                sierra = case.get("sierra_code", "").strip()
+                if not sierra:
+                    continue
+
+                # The test name is the first section key (not a section called "test_name")
+                order = case.get("_order", [])
+                if not order:
+                    continue
+                test_name = order[0]
+
+                safe_name = sanitize_name(test_name)
+                if not safe_name:
+                    continue
+
+                out_dir = os.path.join(DST_DIR, rel_dir, filename)
+                os.makedirs(out_dir, exist_ok=True)
+                out_path = os.path.join(out_dir, f"{safe_name}.sierra")
+
+                with open(out_path, "w") as f:
+                    f.write(sierra + "\n")
+                count += 1
+
+    print(f"Extracted {count} sierra files into {DST_DIR}/")
+
+
+if __name__ == "__main__":
+    main()

scripts/pull_external_projects.py

@@ -39,3 +39,8 @@
         os.path.join(root, "crates/cairo-lang-starknet/cairo_level_tests"),
         "test_data/tests_starknet/cairo_level_tests",
     )
+    shutil.rmtree("test_data/e2e_libfuncs_raw", ignore_errors=True)
+    shutil.copytree(
+        os.path.join(root, "tests/e2e_test_data/libfuncs"),
+        "test_data/e2e_libfuncs_raw",
+    )

src/libfuncs/circuit.rs

@@ -102,6 +102,8 @@ fn build_init_circuit_data<'ctx, 'this>(
     metadata: &mut MetadataStorage,
     info: &SignatureAndTypeConcreteLibfunc,
 ) -> Result<()> {
+    metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
+
     let circuit_info = match registry.get_type(&info.ty)? {
         CoreTypeConcrete::Circuit(CircuitTypeConcrete::Circuit(info)) => &info.circuit_info,
         _ => return Err(SierraAssertError::BadTypeInfo.into()),
@@ -307,6 +309,8 @@ fn build_eval<'ctx, 'this>(
     metadata: &mut MetadataStorage,
     info: &SignatureAndTypeConcreteLibfunc,
 ) -> Result<()> {
+    metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
+
     let circuit_info = match registry.get_type(&info.ty)? {
         CoreTypeConcrete::Circuit(CircuitTypeConcrete::Circuit(info)) => &info.circuit_info,
         _ => return Err(SierraAssertError::BadTypeInfo.into()),

src/types/circuit.rs

@@ -111,6 +111,10 @@ pub fn build_circuit_accumulator<'ctx>(
     metadata: &mut MetadataStorage,
     info: WithSelf<InfoOnlyConcreteType>,
 ) -> Result<Type<'ctx>> {
+    if metadata.get::<ReallocBindingsMeta>().is_none() {
+        metadata.insert(ReallocBindingsMeta::new(context, module));
+    }
+
     let Some(GenericArg::Type(circuit_type_id)) = info.info.long_id.generic_args.first() else {
         return Err(SierraAssertError::BadTypeInfo.into());
     };
@@ -211,6 +215,10 @@ pub fn build_circuit_data<'ctx>(
     metadata: &mut MetadataStorage,
     info: WithSelf<InfoOnlyConcreteType>,
 ) -> Result<Type<'ctx>> {
+    if metadata.get::<ReallocBindingsMeta>().is_none() {
+        metadata.insert(ReallocBindingsMeta::new(context, module));
+    }
+
     let Some(GenericArg::Type(circuit_type_id)) = info.info.long_id.generic_args.first() else {
         return Err(SierraAssertError::BadTypeInfo.into());
     };
@@ -302,6 +310,10 @@ pub fn build_circuit_outputs<'ctx>(
     metadata: &mut MetadataStorage,
     info: WithSelf<InfoOnlyConcreteType>,
 ) -> Result<Type<'ctx>> {
+    if metadata.get::<ReallocBindingsMeta>().is_none() {
+        metadata.insert(ReallocBindingsMeta::new(context, module));
+    }
+
     let Some(GenericArg::Type(circuit_type_id)) = info.info.long_id.generic_args.first() else {
         return Err(SierraAssertError::BadTypeInfo.into());
     };

tests/tests/e2e_libfuncs.rs

@@ -0,0 +1,74 @@
+use cairo_lang_sierra::ProgramParser;
+use cairo_native::context::NativeContext;
+use std::fs;
+use std::path::Path;
+
+/// Collects all `.sierra` files under the e2e_sierra directory and compiles each
+/// through cairo-native (Sierra → LLVM) to verify they compile without errors.
+#[test]
+fn compile_e2e_libfunc_sierra() {
+    let sierra_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("test_data/e2e_sierra");
+    if !sierra_dir.exists() {
+        eprintln!(
+            "Skipping e2e libfunc tests: {} not found. Run 'make pull-external-projects' first.",
+            sierra_dir.display()
+        );
+        return;
+    }
+
+    let context = NativeContext::new();
+    let parser = ProgramParser::new();
+
+    let mut total = 0;
+    let mut failures = Vec::new();
+
+    for entry in walkdir::WalkDir::new(&sierra_dir)
+        .sort_by_file_name()
+        .into_iter()
+    {
+        let entry = entry.unwrap();
+        let path = entry.path();
+        if path.extension().is_some_and(|e| e == "sierra") {
+            total += 1;
+            let source = fs::read_to_string(path).unwrap();
+            let rel_path = path.strip_prefix(&sierra_dir).unwrap();
+
+            let program = match parser.parse(&source) {
+                Ok(p) => p,
+                Err(e) => {
+                    failures.push(format!("{}: parse error: {e}", rel_path.display()));
+                    continue;
+                }
+            };
+
+            eprintln!("compiling {}", rel_path.display());
+            if let Err(e) = context.compile(&program, false, Some(Default::default()), None) {
+                failures.push(format!("{}: compile error: {e}", rel_path.display()));
+            }
+        }
+    }
+
+    assert!(
+        total > 0,
+        "No .sierra files found in {}",
+        sierra_dir.display()
+    );
+
+    if !failures.is_empty() {
+        panic!(
+            "{}/{} e2e libfunc sierra files failed to compile:\n{}",
+            failures.len(),
+            total,
+            failures.join("\n")
+        );
+    }
+}
+
+fn sorted_read_dir(dir: &Path) -> Vec<std::path::PathBuf> {
+    let mut entries: Vec<_> = fs::read_dir(dir)
+        .unwrap()
+        .map(|e| e.unwrap().path())
+        .collect();
+    entries.sort();
+    entries
+}

tests/tests/mod.rs

@@ -5,6 +5,7 @@ pub mod cases;
 pub mod circuit;
 pub mod compile_library;
 pub mod dict;
+pub mod e2e_libfuncs;
 pub mod ec;
 pub mod felt252;
 pub mod libfuncs;