Memcpy hints

pkg/hints/hint_processor.go

@@ -57,6 +57,8 @@ func (p *CairoVmHintProcessor) ExecuteHint(vm *vm.VirtualMachine, hintData *any,
 		return dictWrite(data.Ids, execScopes, vm)
 	case DICT_UPDATE:
 		return dictUpdate(data.Ids, execScopes, vm)
+	case VM_ENTER_SCOPE:
+		return vm_enter_scope(execScopes)
 	case VM_EXIT_SCOPE:
 		return vm_exit_scope(execScopes)
 	case ASSERT_NOT_EQUAL:
@@ -67,8 +69,12 @@ func (p *CairoVmHintProcessor) ExecuteHint(vm *vm.VirtualMachine, hintData *any,
 		return sqrt(data.Ids, vm)
 	case MEMCPY_ENTER_SCOPE:
 		return memcpy_enter_scope(data.Ids, vm, execScopes)
-	case VM_ENTER_SCOPE:
-		return vm_enter_scope(execScopes)
+	case MEMSET_ENTER_SCOPE:
+		return memset_enter_scope(data.Ids, vm, execScopes)
+	case MEMCPY_CONTINUE_COPYING:
+		return memset_step_loop(data.Ids, vm, execScopes, "continue_copying")
+	case MEMSET_CONTINUE_LOOP:
+		return memset_step_loop(data.Ids, vm, execScopes, "continue_loop")
 	default:
 		return errors.Errorf("Unknown Hint: %s", data.Code)
 	}

pkg/hints/hint_utils/ids_manager.go

@@ -25,6 +25,10 @@ func ErrUnknownIdentifier(name string) error {
 	return ErrIdsManager(errors.Errorf("Unknow identifier %s", name))
 }
 
+func ErrIdentifierNotFelt(name string) error {
+	return ErrIdsManager(errors.Errorf("Identifier %s is not a Felt", name))
+}
+
 func NewIdsManager(references map[string]HintReference, hintApTracking parser.ApTrackingData, accessibleScopes []string) IdsManager {
 	return IdsManager{
 		References:       references,
@@ -67,7 +71,7 @@ func (ids *IdsManager) GetFelt(name string, vm *VirtualMachine) (lambdaworks.Fel
 	}
 	felt, is_felt := val.GetFelt()
 	if !is_felt {
-		return lambdaworks.Felt{}, errors.Errorf("Identifier %s is not a Felt", name)
+		return lambdaworks.Felt{}, ErrIdentifierNotFelt(name)
 	}
 	return felt, nil
 }

pkg/hints/memcpy_hint_codes.go

@@ -4,3 +4,4 @@ const ADD_SEGMENT = "memory[ap] = segments.add()"
 const VM_EXIT_SCOPE = "vm_exit_scope()"
 const VM_ENTER_SCOPE = "vm_enter_scope()"
 const MEMCPY_ENTER_SCOPE = "vm_enter_scope({'n': ids.len})"
+const MEMCPY_CONTINUE_COPYING = "n -= 1 ids.continue_copying = 1 if n > 0 else 0"

pkg/hints/memcpy_hints.go

@@ -2,7 +2,8 @@ package hints
 
 import (
 	. "github.com/lambdaclass/cairo-vm.go/pkg/hints/hint_utils"
-	"github.com/lambdaclass/cairo-vm.go/pkg/types"
+	. "github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
+	. "github.com/lambdaclass/cairo-vm.go/pkg/types"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/vm"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/vm/memory"
 )
@@ -15,13 +16,13 @@ func add_segment(vm *VirtualMachine) error {
 
 // Implements hint:
 // %{ vm_exit_scope() %}
-func vm_exit_scope(executionScopes *types.ExecutionScopes) error {
+func vm_exit_scope(executionScopes *ExecutionScopes) error {
 	return executionScopes.ExitScope()
 }
 
 // Implements hint:
 // %{ vm_enter_scope({'n': ids.len}) %}
-func memcpy_enter_scope(ids IdsManager, vm *VirtualMachine, execScopes *types.ExecutionScopes) error {
+func memcpy_enter_scope(ids IdsManager, vm *VirtualMachine, execScopes *ExecutionScopes) error {
 	len, err := ids.GetFelt("len", vm)
 	if err != nil {
 		return err
@@ -31,8 +32,40 @@ func memcpy_enter_scope(ids IdsManager, vm *VirtualMachine, execScopes *types.Ex
 	return nil
 }
 
+/*
+	Implements hint:
+
+	%{
+	    n -= 1
+	    ids.`i_name` = 1 if n > 0 else 0
+
+%}
+*/
+func memset_step_loop(ids IdsManager, vm *VirtualMachine, execScoes *ExecutionScopes, i_name string) error {
+	// get `n` variable from vm scope
+	n, err := execScoes.GetRef("n")
+	if err != nil {
+		return err
+	}
+	// this variable will hold the value of `n - 1`
+	*n = (*n).(Felt).Sub(FeltOne())
+	// if `new_n` is positive, insert 1 in the address of `continue_loop`
+	// else, insert 0
+	var flag *MaybeRelocatable
+	if (*n).(Felt).IsPositive() {
+		flag = NewMaybeRelocatableFelt(FeltOne())
+	} else {
+		flag = NewMaybeRelocatableFelt(FeltZero())
+	}
+	err = ids.Insert(i_name, flag, vm)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 // Implements hint: vm_enter_scope()
-func vm_enter_scope(executionScopes *types.ExecutionScopes) error {
+func vm_enter_scope(executionScopes *ExecutionScopes) error {
 	executionScopes.EnterScope(make(map[string]interface{}))
 	return nil
 }

pkg/hints/memcpy_hints_test.go

@@ -5,14 +5,14 @@ import (
 
 	. "github.com/lambdaclass/cairo-vm.go/pkg/hints"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/hints/hint_utils"
-	"github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/lambdaworks"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/types"
+	. "github.com/lambdaclass/cairo-vm.go/pkg/utils"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/vm"
 	. "github.com/lambdaclass/cairo-vm.go/pkg/vm/memory"
 )
 
-func AddSegmentHintOk(t *testing.T) {
+func TestAddSegmentHintOk(t *testing.T) {
 	vm := NewVirtualMachine()
 	initial_segments := vm.Segments.Memory.NumSegments()
 	hintProcessor := CairoVmHintProcessor{}
@@ -106,8 +106,8 @@ func TestMemcpyEnterScopeHintValid(t *testing.T) {
 	if err != nil {
 		t.Errorf("TestMemcpyEnterScopeHintValid failed with error %s", err)
 	}
-	if res.(lambdaworks.Felt) != lambdaworks.FeltFromDecString("45") {
-		t.Errorf("TestMemcpyEnterScopeHintValid failed, expected len: %d, got: %d", lambdaworks.FeltFromDecString("45"), res.(lambdaworks.Felt))
+	if res.(Felt) != FeltFromDecString("45") {
+		t.Errorf("TestMemcpyEnterScopeHintValid failed, expected len: %d, got: %d", FeltFromDecString("45"), res.(Felt))
 	}
 }
 
@@ -155,3 +155,86 @@ func TestEnterScope(t *testing.T) {
 		t.Errorf("TestEnterScopeHint failed with error %s", err)
 	}
 }
+
+func TestMemcpyContinueCopyingValid(t *testing.T) {
+	vm := NewVirtualMachine()
+	vm.Segments = AddNSegments(vm.Segments, 3)
+	vm.RunContext.Fp = NewRelocatable(2, 0)
+	vm.Segments.Memory.Data[NewRelocatable(1, 2)] = *NewMaybeRelocatableFelt(FeltFromUint64(5))
+
+	executionScopes := NewExecutionScopes()
+	scope := make(map[string]interface{})
+	scope["n"] = FeltOne()
+	executionScopes.EnterScope(scope)
+
+	idsManager := SetupIdsForTest(
+		map[string][]*MaybeRelocatable{
+			"continue_copying": nil,
+		},
+		vm,
+	)
+	hintProcessor := CairoVmHintProcessor{}
+	hintData := any(HintData{
+		Ids:  idsManager,
+		Code: MEMCPY_CONTINUE_COPYING,
+	})
+
+	err := hintProcessor.ExecuteHint(vm, &hintData, nil, executionScopes)
+	if err != nil {
+		t.Errorf("TestMemsetContinueLoopValidEqual1 failed with error %s", err)
+	}
+}
+
+func TestMemcpyContinueCopyingVarNotInScope(t *testing.T) {
+	vm := NewVirtualMachine()
+	vm.Segments.AddSegment()
+	vm.RunContext.Fp = NewRelocatable(3, 0)
+	vm.Segments.Memory.Insert(NewRelocatable(0, 2), NewMaybeRelocatableFelt(FeltFromUint64(5)))
+
+	executionScopes := NewExecutionScopes()
+
+	idsManager := SetupIdsForTest(
+		map[string][]*MaybeRelocatable{
+			"continue_copying": nil,
+		},
+		vm,
+	)
+	hintProcessor := CairoVmHintProcessor{}
+	hintData := any(HintData{
+		Ids:  idsManager,
+		Code: MEMCPY_CONTINUE_COPYING,
+	})
+
+	err := hintProcessor.ExecuteHint(vm, &hintData, nil, executionScopes)
+	if err.Error() != ErrVariableNotInScope("n").Error() {
+		t.Errorf("TestMemcpyContinueCopyingVarNotInScope should fail with error %s", ErrVariableNotInScope("n"))
+	}
+}
+
+func TestMemcpyContinueCopyingInsertError(t *testing.T) {
+	vm := NewVirtualMachine()
+	vm.Segments = AddNSegments(vm.Segments, 2)
+	executionScopes := NewExecutionScopes()
+
+	scope := make(map[string]interface{})
+	scope["n"] = FeltOne()
+	executionScopes.EnterScope(scope)
+
+	idsManager := SetupIdsForTest(
+		map[string][]*MaybeRelocatable{
+			"continue_copying": {NewMaybeRelocatableFelt(FeltFromUint64(5))},
+		},
+		vm,
+	)
+	hintProcessor := CairoVmHintProcessor{}
+	hintData := any(HintData{
+		Ids:  idsManager,
+		Code: MEMCPY_CONTINUE_COPYING,
+	})
+
+	err := hintProcessor.ExecuteHint(vm, &hintData, nil, executionScopes)
+	expected := ErrMemoryWriteOnce(NewRelocatable(0, 0), *NewMaybeRelocatableFeltFromUint64(5), *NewMaybeRelocatableFeltFromUint64(0))
+	if err.Error() != expected.Error() {
+		t.Errorf("TestMemcpyContinueCopyingInsertError should fail with error %s", expected)
+	}
+}

pkg/hints/memset_hint_codes.go

@@ -0,0 +1,4 @@
+package hints
+
+const MEMSET_ENTER_SCOPE = "vm_enter_scope({'n': ids.n})"
+const MEMSET_CONTINUE_LOOP = "n -= 1 ids.continue_loop = 1 if n > 0 else 0"

pkg/hints/memset_hints.go

@@ -0,0 +1,18 @@
+package hints
+
+import (
+	. "github.com/lambdaclass/cairo-vm.go/pkg/hints/hint_utils"
+	. "github.com/lambdaclass/cairo-vm.go/pkg/types"
+	. "github.com/lambdaclass/cairo-vm.go/pkg/vm"
+)
+
+// Implements hint:
+// %{ vm_enter_scope({'n': ids.n}) %}
+func memset_enter_scope(ids IdsManager, vm *VirtualMachine, execScopes *ExecutionScopes) error {
+	n, err := ids.GetFelt("n", vm)
+	if err != nil {
+		return err
+	}
+	execScopes.EnterScope(map[string]interface{}{"n": n})
+	return nil
+}