Execution

pkg/lambdaworks/lambdaworks.go

@@ -6,7 +6,9 @@ package lambdaworks
 #include <stdlib.h>
 */
 import "C"
+
 import (
+	"errors"
 	"unsafe"
 )
 
@@ -104,6 +106,16 @@ func (a Felt) Mul(b Felt) Felt {
 }
 
 // Writes the result variable with a / b.
+
+// turns a felt to usize
+func (felt Felt) ToU64() (uint64, error) {
+	if felt.limbs[0] == 0 && felt.limbs[1] == 0 && felt.limbs[2] == 0 {
+		return uint64(felt.limbs[3]), nil
+	} else {
+		return 0, errors.New("Cannot convert felt to u64")
+	}
+}
+
 func (a Felt) Div(b Felt) Felt {
 	var result C.felt_t
 	var a_c C.felt_t = a.toC()

pkg/lambdaworks/lambdaworks_test.go

@@ -47,6 +47,7 @@ func TestFeltSub(t *testing.T) {
 }
 
 func TestFeltAdd(t *testing.T) {
+
 	var felt Felt
 	f_zero := felt.Zero()
 	f_one := felt.One()
@@ -114,6 +115,7 @@ func TestFeltDiv4(t *testing.T) {
 }
 
 func TestFeltDiv4Error(t *testing.T) {
+
 	f_four := FeltFromUint64(4)
 	f_one := FeltFromUint64(1)
 

pkg/lambdaworks/lib/lambdaworks/src/lib.rs

@@ -103,3 +103,5 @@ pub extern "C" fn mul(a: Limbs, b: Limbs, result: Limbs) {
 pub extern "C" fn lw_div(a: Limbs, b: Limbs, result: Limbs) {
     felt_to_limbs(limbs_to_felt(a) / limbs_to_felt(b), result)
 }
+
+

pkg/runners/cairo_runner.go

@@ -21,7 +21,7 @@ func NewCairoRunner(program vm.Program) *CairoRunner {
 	// TODO: Fetch main entrypoint offset from program identifiers
 	// Placeholder
 	main_offset := uint(0)
-	return &CairoRunner{Program: program, Vm: *vm.NewVirtualMachine(), mainOffset: main_offset}
+	return &CairoRunner{Program: program, Vm: vm.NewVirtualMachine(), mainOffset: main_offset}
 
 }
 

pkg/runners/cairo_runner_test.go

@@ -3,6 +3,7 @@ package runners_test
 import (
 	"testing"
 
+	"github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
 	"github.com/lambdaclass/cairo-vm.go/pkg/runners"
 	"github.com/lambdaclass/cairo-vm.go/pkg/vm"
 	"github.com/lambdaclass/cairo-vm.go/pkg/vm/memory"
@@ -72,7 +73,7 @@ func TestInitializeRunnerNoBuiltinsNoProofModeEmptyProgram(t *testing.T) {
 func TestInitializeRunnerNoBuiltinsNoProofModeNonEmptyProgram(t *testing.T) {
 	// Create a Program with one fake instruction
 	program_data := make([]memory.MaybeRelocatable, 1)
-	program_data[0] = *memory.NewMaybeRelocatableInt(1)
+	program_data[0] = *memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(1))
 	program := vm.Program{Data: program_data}
 	// Create CairoRunner
 	runner := runners.NewCairoRunner(program)
@@ -110,7 +111,7 @@ func TestInitializeRunnerNoBuiltinsNoProofModeNonEmptyProgram(t *testing.T) {
 		t.Errorf("Memory Get error in test: %s", err)
 	}
 	int, ok := value.GetInt()
-	if !ok || int.Felt != 1 {
+	if !ok || int.Felt != lambdaworks.FeltFromUint64(1) {
 		t.Errorf("Wrong value for address 0:0: %d", int)
 	}
 

pkg/vm/instruction.go

@@ -36,6 +36,13 @@ type Instruction struct {
 	Opcode   Opcode
 }
 
+func (i *Instruction) size() uint {
+	if i.Op1Addr == Op1SrcImm {
+		return 2
+	}
+	return 1
+}
+
 // x-----------------------------x
 // x----- Instruction flags -----x
 // x-----------------------------x

pkg/vm/memory/memory.go

@@ -38,7 +38,6 @@ func (m *Memory) Insert(addr Relocatable, val *MaybeRelocatable) error {
 	if ok && prev_elem != *val {
 		return errors.New("Memory is write-once, cannot overwrite memory value")
 	}
-
 	m.data[addr] = *val
 
 	return nil

pkg/vm/memory/memory_test.go

@@ -4,6 +4,7 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
 	"github.com/lambdaclass/cairo-vm.go/pkg/vm/memory"
 )
 
@@ -16,7 +17,7 @@ func TestMemoryInsert(t *testing.T) {
 	// Instantiate the address where we want to insert and the value.
 	// We will insert the value Int(5) in segment 1, offset 0
 	key := memory.NewRelocatable(1, 0)
-	val := memory.NewMaybeRelocatableInt(5)
+	val := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(5))
 
 	// Make the insertion
 	err := mem.Insert(key, val)
@@ -45,7 +46,7 @@ func TestMemoryInsertWithHoles(t *testing.T) {
 	// Instantiate the address where we want to insert and the value.
 	// We will insert the MaybeRelocatable Int(7) in segment 1, offset 2
 	key := memory.NewRelocatable(1, 2)
-	val := memory.NewMaybeRelocatableInt(7)
+	val := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(7))
 
 	// Make the insertion
 	err := mem.Insert(key, val)
@@ -71,7 +72,7 @@ func TestMemoryInsertOverWriteSameValue(t *testing.T) {
 
 	// We will insert the MaybeRelocatable Int(7) in segment 0, offset 0
 	key := mem_manager.AddSegment()
-	val := memory.NewMaybeRelocatableInt(7)
+	val := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(7))
 
 	// Make the insertion
 	err := mem.Insert(key, val)
@@ -92,7 +93,7 @@ func TestMemoryInsertOverWriteValue(t *testing.T) {
 
 	// We will insert the MaybeRelocatable Int(7) in segment 0, offset 0
 	key := mem_manager.AddSegment()
-	val := memory.NewMaybeRelocatableInt(7)
+	val := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(7))
 
 	// Make the insertion
 	err := mem.Insert(key, val)
@@ -101,7 +102,7 @@ func TestMemoryInsertOverWriteValue(t *testing.T) {
 	}
 
 	// Insert another value into the same address and check that it fails
-	val2 := memory.NewMaybeRelocatableInt(8)
+	val2 := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(8))
 	err2 := mem.Insert(key, val2)
 	if err2 == nil {
 		t.Errorf("Overwritting memory value should fail")
@@ -115,7 +116,7 @@ func TestMemoryInsertUnallocatedSegment(t *testing.T) {
 	// Instantiate the address where we want to insert and the value.
 	// We will insert the value Int(5) in segment 1, offset 0
 	key := memory.NewRelocatable(1, 0)
-	val := memory.NewMaybeRelocatableInt(5)
+	val := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(5))
 
 	// Make the insertion
 	err := mem.Insert(key, val)
@@ -128,7 +129,7 @@ func TestMemorySegmentsLoadDataUnallocatedSegment(t *testing.T) {
 	mem_manager := memory.NewMemorySegmentManager()
 
 	ptr := memory.NewRelocatable(1, 0)
-	data := []memory.MaybeRelocatable{*memory.NewMaybeRelocatableInt(5)}
+	data := []memory.MaybeRelocatable{*memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(5))}
 
 	// Load Data
 	_, err := mem_manager.LoadData(ptr, &data)
@@ -142,7 +143,7 @@ func TestMemorySegmentsLoadDataOneElement(t *testing.T) {
 	mem_manager.AddSegment()
 
 	ptr := memory.NewRelocatable(0, 0)
-	val := memory.NewMaybeRelocatableInt(5)
+	val := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(5))
 	data := []memory.MaybeRelocatable{*val}
 
 	// Load Data
@@ -174,8 +175,8 @@ func TestMemorySegmentsLoadDataTwoElements(t *testing.T) {
 	mem_manager.AddSegment()
 
 	ptr := memory.NewRelocatable(0, 0)
-	val := memory.NewMaybeRelocatableInt(5)
-	val2 := memory.NewMaybeRelocatableInt(5)
+	val := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(5))
+	val2 := memory.NewMaybeRelocatableInt(lambdaworks.FeltFromUint64(5))
 	data := []memory.MaybeRelocatable{*val, *val2}
 
 	// Load Data

pkg/vm/memory/relocatable.go

@@ -3,6 +3,8 @@ package memory
 import (
 	"errors"
 	"fmt"
+
+	"github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
 )
 
 // Relocatable in the Cairo VM represents an address
@@ -24,12 +26,28 @@ func (r *Relocatable) RelocateAddress(relocationTable *[]uint) uint {
 	return (*relocationTable)[r.SegmentIndex] + r.Offset
 }
 
+func (r *Relocatable) IsEqual(r1 *Relocatable) bool {
+	return (r.SegmentIndex == r1.SegmentIndex && r.Offset == r1.Offset)
+}
+
+func (relocatable *Relocatable) SubUint(other uint) (Relocatable, error) {
+	if relocatable.Offset < other {
+		return NewRelocatable(0, 0), &SubReloctableError{Msg: "RelocatableSubUsizeNegOffset"}
+	} else {
+		new_offset := relocatable.Offset - other
+		return NewRelocatable(relocatable.SegmentIndex, new_offset), nil
+	}
+}
+
+func (relocatable *Relocatable) AddUint(other uint) (Relocatable, error) {
+	new_offset := relocatable.Offset + other
+	return NewRelocatable(relocatable.SegmentIndex, new_offset), nil
+}
+
 // Int in the Cairo VM represents a value in memory that
 // is not an address.
 type Int struct {
-	// FIXME: Here we should use Lambdaworks felt, just mocking
-	// this for now.
-	Felt uint
+	Felt lambdaworks.Felt
 }
 
 // MaybeRelocatable is the type of the memory cells in the Cairo
@@ -41,7 +59,7 @@ type MaybeRelocatable struct {
 }
 
 // Creates a new MaybeRelocatable with an Int inner value
-func NewMaybeRelocatableInt(felt uint) *MaybeRelocatable {
+func NewMaybeRelocatableInt(felt lambdaworks.Felt) *MaybeRelocatable {
 	return &MaybeRelocatable{inner: Int{felt}}
 }
 
@@ -65,17 +83,68 @@ func (m *MaybeRelocatable) GetRelocatable() (Relocatable, bool) {
 // Turns a MaybeRelocatable into a Felt252 value.
 // If the inner value is an Int, it will extract the Felt252 value from it.
 // If the inner value is a Relocatable, it will relocate it according to the relocation_table
-// TODO: Return value should be of type (felt, error)
-func (m *MaybeRelocatable) RelocateValue(relocationTable *[]uint) (uint, error) {
+func (m *MaybeRelocatable) RelocateValue(relocationTable *[]uint) (lambdaworks.Felt, error) {
 	inner_int, ok := m.GetInt()
 	if ok {
 		return inner_int.Felt, nil
 	}
 
 	inner_relocatable, ok := m.GetRelocatable()
 	if ok {
-		return inner_relocatable.RelocateAddress(relocationTable), nil
+		return lambdaworks.FeltFromUint64(uint64(inner_relocatable.RelocateAddress(relocationTable))), nil
 	}
 
-	return 0, errors.New(fmt.Sprintf("Unexpected type %T", m.inner))
+	return lambdaworks.FeltFromUint64(0), errors.New(fmt.Sprintf("Unexpected type %T", m.inner))
+}
+
+func (m *MaybeRelocatable) IsEqual(m1 *MaybeRelocatable) bool {
+	a, a_type := m.GetInt()
+	b, b_type := m1.GetInt()
+	if a_type == b_type {
+		if a_type {
+			return a == b
+		} else {
+			a, _ := m.GetRelocatable()
+			b, _ := m1.GetRelocatable()
+			return a.IsEqual(&b)
+		}
+	} else {
+		return false
+	}
+}
+
+func (m MaybeRelocatable) AddMaybeRelocatable(other MaybeRelocatable) (MaybeRelocatable, error) {
+	// check if they are felt
+	m_int, m_type := m.GetInt()
+	other_int, other_type := other.GetInt()
+
+	if m_type && other_type {
+		result := NewMaybeRelocatableInt(m_int.Felt.Add(other_int.Felt))
+		return *result, nil
+	}
+	// check if one is relocatable and the other int
+	m_rel, is_rel_m := m.GetRelocatable()
+	other_rel, is_rel_other := other.GetRelocatable()
+
+	if is_rel_m && !is_rel_other {
+
+		other_felt, _ := other.GetInt()
+		other_usize, _ := other_felt.Felt.ToU64()
+		offset := m_rel.Offset
+		new_offset := uint64(offset) + other_usize
+		rel := NewRelocatable(m_rel.SegmentIndex, uint(new_offset))
+		res := NewMaybeRelocatableRelocatable(rel)
+		return *res, nil
+	} else if !is_rel_m && is_rel_other {
+
+		m_felt, _ := m.GetInt()
+		m_usize, _ := m_felt.Felt.ToU64()
+		offset := other_rel.Offset
+		new_offset := uint64(offset) + m_usize
+		rel := NewRelocatable(other_rel.SegmentIndex, uint(new_offset))
+		res := NewMaybeRelocatableRelocatable(rel)
+		return *res, nil
+	} else {
+		return MaybeRelocatable{}, errors.New("RelocatableAdd")
+	}
 }

pkg/vm/memory/relocatable_err.go

@@ -0,0 +1,9 @@
+package memory
+
+type SubReloctableError struct {
+	Msg string
+}
+
+func (e *SubReloctableError) Error() string {
+	return e.Msg
+}

pkg/vm/memory/segments.go

@@ -8,9 +8,9 @@ type MemorySegmentManager struct {
 	Memory       Memory
 }
 
-func NewMemorySegmentManager() *MemorySegmentManager {
+func NewMemorySegmentManager() MemorySegmentManager {
 	memory := NewMemory()
-	return &MemorySegmentManager{make(map[uint]uint), *memory}
+	return MemorySegmentManager{make(map[uint]uint), *memory}
 }
 
 // Adds a memory segment and returns the first address of the new segment
@@ -67,7 +67,9 @@ func (s *MemorySegmentManager) RelocateMemory(relocationTable *[]uint) (map[uint
 				if err != nil {
 					return nil, err
 				}
-				relocatedMemory[relocatedAddr] = value
+				// Todo: fix this, should be a felt
+				val, _ := value.ToU64()
+				relocatedMemory[relocatedAddr] = uint(val)
 			}
 		}
 	}