feat: Cairo 1 programs and Hint processor

.gitignore

@@ -4,3 +4,4 @@ dist
 
 # Cairo compilation artifacts
 cairo_programs/**/*.json
+cairo_programs/**/*.sierra

.gitmodules

@@ -5,3 +5,8 @@
 [submodule "ziggy-starkdust"]
 	path = ziggy-starkdust
 	url = [email protected]:keep-starknet-strange/ziggy-starkdust.git
+	shallow = true
+[submodule "cairo"]
+	path = cairo
+	url = [email protected]:zmalatrax/cairo.git
+	shallow = true

.trunk/trunk.yaml

@@ -37,6 +37,10 @@ lint:
     - [email protected]
     - [email protected]
     - [email protected]
+  ignore:
+    - linters: [cairo]
+      paths:
+        - cairo_programs/cairo/**
 actions:
   disabled:
     - trunk-announce

Makefile

@@ -1,4 +1,6 @@
-.PHONY: compile run-all diff-test bench build build-cairo-vm-cli build-cairo-vm-rs-cli build-cairo-vm-zig-cli clean-diff-test clean--bench clean-tmp
+.PHONY: compile-cairo-zero compile-cairo compile build build-cairo-vm-cli \
+build-cairo-vm-rs-cli build-cairo-vm-zig-cli build-cairo build-sierra-compiler build-cairo-compiler \
+run-all diff-test bench clean-diff-test clean-bench clean-tmp
 
 # Clone & build the other VMs - Assume that related lang are installed
 CAIRO_VM_RS_CLI:=cairo-vm/target/release/cairo-vm-cli
@@ -23,6 +25,23 @@ build-cairo-vm-zig-cli: | $(CAIRO_VM_ZIG_CLI)
 
 build-cairo-vm-cli: build build-cairo-vm-rs-cli build-cairo-vm-zig-cli
 
+CAIRO_COMPILER=cairo/target/release/cairo-compile
+SIERRA_COMPILER=cairo/target/release/sierra-compile-json
+
+$(CAIRO_COMPILER):
+	@git submodule init; \
+	git submodule update; \
+	cd cairo; cargo build --release --bin cairo-compile
+
+$(SIERRA_COMPILER):
+	@git submodule init; \
+	git submodule update; \
+	cd cairo; cargo build --release --bin sierra-compile-json
+
+build-cairo-compiler: | $(CAIRO_COMPILER)
+build-sierra-compiler: | $(SIERRA_COMPILER)
+build-cairo: build-cairo-compiler build-sierra-compiler
+
 TMP_PREFIX="cairo-vm-ts"
 
 CAIRO_0_PATH=cairo_programs/cairo_0
@@ -34,11 +53,27 @@ COMPILED_CAIRO_0_FILES:=$(CAIRO_0_FILES:%.cairo=%.json)
 COMPILED_CAIRO_0_BENCHMARK_FILES:=$(CAIRO_0_BENCHMARK_FILES:%.cairo=%.json)
 VALID_COMPILED_CAIRO_0_FILES:=$(VALID_CAIRO_0_FILES:%.cairo=%.json)
 
-compile: $(COMPILED_CAIRO_0_FILES)
+CAIRO_PATH=cairo_programs/cairo/
+CAIRO_FILES:=$(shell find $(CAIRO_PATH) -name '*.cairo')
+SIERRA_FILES:=$(CAIRO_FILES:%.cairo=%.sierra)
+COMPILED_CAIRO_FILES:=$(SIERRA_FILES:%.sierra=%.json)
+
+$(COMPILED_CAIRO_FILES): %.json: %.sierra
+	$(SIERRA_COMPILER) $< $@
 
 %.json: %.cairo
 	poetry run cairo-compile $< --output $@
 
+%.sierra: %.cairo
+	$(CAIRO_COMPILER) -r -s $< $@
+
+
+compile-cairo-zero: $(COMPILED_CAIRO_0_FILES)
+compile-cairo: $(COMPILED_CAIRO_FILES)
+compile: compile-cairo-zero compile-cairo
+
+
+
 run-all: $(VALID_COMPILED_CAIRO_0_FILES)
 	@failed_tests_ctr=0; \
 	failed_tests=""; \

cairo_programs/cairo/add.cairo

@@ -0,0 +1,3 @@
+fn main() -> felt252 {
+    12 + 10
+}

cairo_programs/cairo/hints/multiple_fn.cairo

@@ -0,0 +1,9 @@
+fn main() -> (bool, bool) {
+    let a = 10_u32;
+    let b = 12_u32;
+    (a < b, b < a)
+}
+
+fn foo() -> u32 {
+    12_u32 ^ 10_u32
+}

cairo_programs/cairo/hints/tensor_new.cairo

@@ -0,0 +1,65 @@
+// FP16x16
+#[derive(Serde, Copy, Drop)]
+struct FP16x16 {
+    mag: u32,
+    sign: bool
+}
+
+trait FixedTrait<T, MAG> {
+    fn new(mag: MAG, sign: bool) -> T;
+}
+
+impl FP16x16Impl of FixedTrait<FP16x16, u32> {
+    fn new(mag: u32, sign: bool) -> FP16x16 {
+        FP16x16 { mag: mag, sign: sign }
+    }
+}
+
+//Tensor
+#[derive(Copy, Drop)]
+struct Tensor<T> {
+    shape: Span<usize>,
+    data: Span<T>,
+}
+
+trait TensorTrait<T> {
+    fn new(shape: Span<usize>, data: Span<T>) -> Tensor<T>;
+}
+
+impl FP16x16Tensor of TensorTrait<FP16x16> {
+    fn new(shape: Span<usize>, data: Span<FP16x16>) -> Tensor<FP16x16> {
+        new_tensor(shape, data)
+    }
+}
+
+fn new_tensor<T>(shape: Span<usize>, data: Span<T>) -> Tensor<T> {
+    check_shape::<T>(shape, data);
+    Tensor::<T> { shape, data }
+}
+
+fn check_shape<T>(shape: Span<usize>, data: Span<T>) {
+    assert(len_from_shape(shape) == data.len(), 'wrong tensor shape');
+}
+
+fn len_from_shape(mut shape: Span<usize>) -> usize {
+    let mut result: usize = 1;
+
+    loop {
+        match shape.pop_front() {
+            Option::Some(item) => { result *= *item; },
+            Option::None => { break; }
+        };
+    };
+
+    result
+}
+
+fn main() -> Tensor<FP16x16> {
+     TensorTrait::new(
+         array![1, 2].span(),
+         array![
+           FixedTrait::new(1, false),
+           FixedTrait::new(1, true)
+         ].span()
+    )
+}

cairo_programs/cairo/hints/test_less_than_args.cairo

@@ -0,0 +1,3 @@
+fn main(a: u32, b: u32, c: u32) {
+    (a < b, b < c);
+}

cairo_programs/cairo/hints/test_less_than_false.cairo

@@ -0,0 +1,3 @@
+fn main() -> bool {
+    12_u32 < 10_u32
+}

cairo_programs/cairo/hints/test_less_than_true.cairo

@@ -0,0 +1,3 @@
+fn main() -> bool {
+    10_u32 < 12_u32
+}

cairo_programs/cairo/hints/u32_overflowing_sub_err.cairo

@@ -0,0 +1,3 @@
+fn main() -> Result<u32, u32> {
+    integer::u32_overflowing_sub(10_u32, 12_u32)
+}

cairo_programs/cairo/hints/u32_overflowing_sub_valid.cairo

@@ -0,0 +1,3 @@
+fn main() -> Result<u32, u32> {
+    integer::u32_overflowing_sub(12_u32, 10_u32)
+}

src/cli.ts

@@ -1,9 +1,9 @@
 #! /usr/bin/env bun
 
 import { Command, Option } from '@commander-js/extra-typings';
-
 import { consola } from 'consola';
 import { Argument } from 'commander';
+
 import { run } from 'scripts/run';
 
 consola.options = {
@@ -30,6 +30,9 @@ program
     })
   )
   .option('-s, --silent', 'silent all logs')
+  .addOption(
+    new Option('--fn <NAME>', 'Function to be executed').default('main')
+  )
   .option('--no-relocate', 'do not relocate memory')
   .addOption(
     new Option(

src/errors/cairoRunner.ts

@@ -1,3 +1,11 @@
 class CairoRunnerError extends Error {}
 
 export class EmptyRelocatedMemory extends CairoRunnerError {}
+
+export class CairoZeroHintsNotSupported extends CairoRunnerError {}
+
+export class UndefinedEntrypoint extends CairoRunnerError {
+  constructor(name: string) {
+    super(`The function to be executed doesn't exist: ${name}`);
+  }
+}

src/errors/hints.ts

@@ -0,0 +1,22 @@
+import { CellRef } from 'hints/hintParamsSchema';
+import { Hint } from 'hints/hintSchema';
+
+class HintError extends Error {}
+
+export class InvalidCellRefRegister extends HintError {
+  constructor(cell: CellRef) {
+    super(`Invalid register, expected AP or FP, got ${cell}`);
+  }
+}
+
+export class InvalidOperation extends HintError {
+  constructor(op: string) {
+    super(`Invalid BinOp operator - Expected Add or Mul, received ${op}`);
+  }
+}
+
+export class UnknownHint extends HintError {
+  constructor(hint: Hint) {
+    super(`Unknown hint: ${hint}`);
+  }
+}

src/hints/allocSegment.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'bun:test';
+
+import { Relocatable } from 'primitives/relocatable';
+import { Register } from 'vm/instruction';
+import { VirtualMachine } from 'vm/virtualMachine';
+import { HintName } from 'hints/hintName';
+import { allocSegmentZod } from './allocSegment';
+
+const ALLOC_SEGMENT = {
+  AllocSegment: {
+    dst: {
+      register: 'AP',
+      offset: 0,
+    },
+  },
+};
+
+describe('AllocSegment', () => {
+  test('should properly parse AllocSegment hint', () => {
+    const hint = allocSegmentZod.parse(ALLOC_SEGMENT);
+    expect(hint).toEqual({
+      type: HintName.AllocSegment,
+      dst: {
+        register: Register.Ap,
+        offset: 0,
+      },
+    });
+  });
+
+  test('should properly execute AllocSegment hint', () => {
+    const hint = allocSegmentZod.parse(ALLOC_SEGMENT);
+    const vm = new VirtualMachine();
+    vm.memory.addSegment();
+    vm.memory.addSegment();
+    expect(vm.memory.getSegmentNumber()).toEqual(2);
+    vm.executeHint(hint);
+    expect(vm.memory.getSegmentNumber()).toEqual(3);
+    expect(vm.memory.get(vm.ap)).toEqual(new Relocatable(2, 0));
+  });
+});

src/hints/allocSegment.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+
+import { VirtualMachine } from 'vm/virtualMachine';
+import { cellRef, CellRef } from 'hints/hintParamsSchema';
+import { HintName } from 'hints/hintName';
+
+/** Zod object to parse AllocSegment hint */
+export const allocSegmentZod = z
+  .object({ AllocSegment: z.object({ dst: cellRef }) })
+  .transform(({ AllocSegment: { dst } }) => ({
+    type: HintName.AllocSegment,
+    dst,
+  }));
+
+/**
+ * AllocSegment hint
+ *
+ * Add a new segment and store its pointer to `dst`
+ */
+export type AllocSegment = z.infer<typeof allocSegmentZod>;
+
+/**
+ * Add a new segment and store its pointer at `dst`
+ */
+export const allocSegment = (vm: VirtualMachine, dst: CellRef) => {
+  const segmentId = vm.memory.addSegment();
+  vm.memory.assertEq(vm.cellRefToRelocatable(dst), segmentId);
+};

src/hints/hintName.ts

@@ -0,0 +1,5 @@
+/** Name to identify which hint is executed  */
+export enum HintName {
+  AllocSegment = 'AllocSegment',
+  TestLessThan = 'TestLessThan',
+}