Chore: some housekeeping on memory pkg

pkg/hintrunner/hint.go

@@ -60,12 +60,12 @@ func (hint TestLessThan) Execute(vm *VM.VirtualMachine) error {
 		return fmt.Errorf("resolve rhs operand %s: %w", hint.rhs, err)
 	}
 
-	lhsFelt, err := lhsVal.ToFieldElement()
+	lhsFelt, err := lhsVal.FieldElement()
 	if err != nil {
 		return err
 	}
 
-	rhsFelt, err := rhsVal.ToFieldElement()
+	rhsFelt, err := rhsVal.FieldElement()
 	if err != nil {
 		return err
 	}

pkg/hintrunner/operand.go

@@ -88,7 +88,7 @@ func (dderef DoubleDeref) Resolve(vm *VM.VirtualMachine) (memory.MemoryValue, er
 	}
 
 	// Double deref implies the left hand side read must be an address
-	address, err := lhs.ToMemoryAddress()
+	address, err := lhs.MemoryAddress()
 	if err != nil {
 		return memory.MemoryValue{}, err
 	}

pkg/vm/builtins/range_check.go

@@ -13,7 +13,7 @@ type RangeCheck struct{}
 var max128 = fp.Element{18446744073700081665, 17407, 18446744073709551584, 576460752142434320}
 
 func (r *RangeCheck) CheckWrite(segment *memory.Segment, offset uint64, value *memory.MemoryValue) error {
-	felt, err := value.ToFieldElement()
+	felt, err := value.FieldElement()
 	if err != nil {
 		return err
 	}

pkg/vm/memory/memory_value.go

@@ -132,8 +132,15 @@ func MemoryValueFromUint[T constraints.Unsigned](v T) MemoryValue {
 	}
 }
 
+// creates a memory value from an index and an offset. If either is negative the result is
+// undefined
 func MemoryValueFromSegmentAndOffset[T constraints.Integer](segmentIndex, offset T) MemoryValue {
-	return MemoryValueFromMemoryAddress(&MemoryAddress{SegmentIndex: uint64(segmentIndex), Offset: uint64(offset)})
+	return MemoryValueFromMemoryAddress(
+		&MemoryAddress{
+			SegmentIndex: uint64(segmentIndex),
+			Offset:       uint64(offset),
+		},
+	)
 }
 
 func MemoryValueFromAny(anyType any) (MemoryValue, error) {
@@ -170,25 +177,21 @@ func EmptyMemoryValueAs(address bool) MemoryValue {
 	}
 }
 
-func (mv *MemoryValue) ToMemoryAddress() (*MemoryAddress, error) {
+func (mv *MemoryValue) MemoryAddress() (*MemoryAddress, error) {
 	if !mv.isAddress {
 		return nil, errors.New("memory value is not an address")
 	}
 	return mv.addrUnsafe(), nil
 }
 
-func (mv *MemoryValue) addrUnsafe() *MemoryAddress {
-	return (*MemoryAddress)(unsafe.Pointer(&mv.felt))
-}
-
-func (mv *MemoryValue) ToFieldElement() (*f.Element, error) {
+func (mv *MemoryValue) FieldElement() (*f.Element, error) {
 	if !mv.isFelt {
 		return nil, fmt.Errorf("memory value is not a field element")
 	}
 	return &mv.felt, nil
 }
 
-func (mv *MemoryValue) ToAny() any {
+func (mv *MemoryValue) Any() any {
 	if mv.isAddress {
 		return mv.addrUnsafe()
 	}
@@ -236,7 +239,7 @@ func (mv *MemoryValue) Add(lhs, rhs *MemoryValue) error {
 // Subs two memory values if they're in the same segment or the rhs is a Felt.
 func (mv *MemoryValue) Sub(lhs, rhs *MemoryValue) error {
 	if lhs.IsAddress() {
-		return mv.addrUnsafe().Sub(lhs.addrUnsafe(), rhs.ToAny())
+		return mv.addrUnsafe().Sub(lhs.addrUnsafe(), rhs.Any())
 	}
 
 	if rhs.IsAddress() {
@@ -281,3 +284,7 @@ func (mv *MemoryValue) Uint64() (uint64, error) {
 
 	return mv.felt.Uint64(), nil
 }
+
+func (mv *MemoryValue) addrUnsafe() *MemoryAddress {
+	return (*MemoryAddress)(unsafe.Pointer(&mv.felt))
+}

pkg/vm/vm.go

@@ -110,7 +110,7 @@ func (vm *VirtualMachine) RunStep(hintRunner HintRunner) error {
 			return fmt.Errorf("reading instruction: %w", err)
 		}
 
-		bytecodeInstruction, err := memoryValue.ToFieldElement()
+		bytecodeInstruction, err := memoryValue.FieldElement()
 		if err != nil {
 			return fmt.Errorf("reading instruction: %w", err)
 		}
@@ -239,7 +239,7 @@ func (vm *VirtualMachine) getOp1Addr(instruction *Instruction, op0Addr *mem.Memo
 			return mem.UnknownValue, fmt.Errorf("cannot read op0: %w", err)
 		}
 
-		op0Address, err := op0Value.ToMemoryAddress()
+		op0Address, err := op0Value.MemoryAddress()
 		if err != nil {
 			return mem.UnknownValue, fmt.Errorf("op0 is not an address: %w", err)
 		}
@@ -398,13 +398,13 @@ func (vm *VirtualMachine) updatePc(
 			Offset:       vm.Context.Pc.Offset + uint64(instruction.Size()),
 		}, nil
 	case Jump:
-		addr, err := res.ToMemoryAddress()
+		addr, err := res.MemoryAddress()
 		if err != nil {
 			return mem.UnknownValue, fmt.Errorf("absolute jump: %w", err)
 		}
 		return *addr, nil
 	case JumpRel:
-		val, err := res.ToFieldElement()
+		val, err := res.FieldElement()
 		if err != nil {
 			return mem.UnknownValue, fmt.Errorf("relative jump: %w", err)
 		}
@@ -417,7 +417,7 @@ func (vm *VirtualMachine) updatePc(
 			return mem.UnknownValue, err
 		}
 
-		dest, err := destMv.ToFieldElement()
+		dest, err := destMv.FieldElement()
 		if err != nil {
 			return mem.UnknownValue, err
 		}
@@ -434,7 +434,7 @@ func (vm *VirtualMachine) updatePc(
 			return mem.UnknownValue, err
 		}
 
-		val, err := op1Mv.ToFieldElement()
+		val, err := op1Mv.FieldElement()
 		if err != nil {
 			return mem.UnknownValue, err
 		}
@@ -477,7 +477,7 @@ func (vm *VirtualMachine) updateFp(instruction *Instruction, dstAddr *mem.Memory
 			return 0, err
 		}
 
-		dst, err := destMv.ToMemoryAddress()
+		dst, err := destMv.MemoryAddress()
 		if err != nil {
 			return 0, fmt.Errorf("ret: %w", err)
 		}