Missing dict functionalities

integration_tests/cairo_vm_test.go

@@ -180,6 +180,7 @@ func TestCairoFiles(t *testing.T) {
 		{"./cairo_zero_file_tests/", true},
 		{"./builtin_tests/", true},
 		// {"./cairo_1_programs/", false},
+		// {"./cairo_1_programs/dict_non_squashed", false},
 	}
 
 	// filter is for debugging purposes

pkg/hintrunner/core/hint.go

@@ -1143,7 +1143,8 @@ func (hint *Felt252DictEntryInit) Execute(vm *VM.VirtualMachine, ctx *hinter.Hin
 
 	prevValue, err := ctx.DictionaryManager.At(dictPtr, key)
 	if err != nil {
-		return fmt.Errorf("get dictionary entry: %w", err)
+		mv := mem.MemoryValueFromFieldElement(&utils.FeltZero)
+		prevValue = &mv
 	}
 	if prevValue == nil {
 		mv := mem.EmptyMemoryValueAsFelt()
@@ -1237,7 +1238,8 @@ func (hint *InitSquashData) Execute(vm *VM.VirtualMachine, ctx *hinter.HintRunne
 	// todo(rodro): Don't know if it could be called multiple times, or
 	err := hinter.InitializeSquashedDictionaryManager(ctx)
 	if err != nil {
-		return err
+		ctx.SquashedDictionaryManager = hinter.SquashedDictionaryManager{}
+		_ = hinter.InitializeSquashedDictionaryManager(ctx)
 	}
 
 	dictAccessPtr, err := hinter.ResolveAsAddress(vm, hint.DictAccesses)
@@ -1272,7 +1274,7 @@ func (hint *InitSquashData) Execute(vm *VM.VirtualMachine, ctx *hinter.HintRunne
 
 	// sort the keys in descending order
 	sort.Slice(ctx.SquashedDictionaryManager.Keys, func(i, j int) bool {
-		return ctx.SquashedDictionaryManager.Keys[i].Cmp(&ctx.SquashedDictionaryManager.Keys[j]) < 0
+		return ctx.SquashedDictionaryManager.Keys[i].Cmp(&ctx.SquashedDictionaryManager.Keys[j]) > 0
 	})
 
 	// if the first key is bigger than 2^128, signal it
@@ -1401,11 +1403,15 @@ func (hint *ShouldContinueSquashLoop) Execute(vm *VM.VirtualMachine, ctx *hinter
 	}
 
 	var shouldContinueLoop f.Element
-	if lastIndices, err := ctx.SquashedDictionaryManager.LastIndices(); err == nil && len(lastIndices) <= 1 {
-		shouldContinueLoop.SetOne()
-	} else if err != nil {
+	lastIndices, err := ctx.SquashedDictionaryManager.LastIndices()
+	if err != nil {
 		return fmt.Errorf("get last indices: %w", err)
 	}
+	if len(lastIndices) > 1 {
+		shouldContinueLoop.SetOne()
+	} else {
+		shouldContinueLoop.SetZero()
+	}
 
 	mv := mem.MemoryValueFromFieldElement(&shouldContinueLoop)
 	return vm.Memory.WriteToAddress(&shouldContinuePtr, &mv)
@@ -1425,11 +1431,15 @@ func (hint *GetNextDictKey) Execute(vm *VM.VirtualMachine, ctx *hinter.HintRunne
 		return fmt.Errorf("get next key address: %w", err)
 	}
 
-	nextKey, err := ctx.SquashedDictionaryManager.PopKey()
+	_, err = ctx.SquashedDictionaryManager.PopKey()
 	if err != nil {
 		return fmt.Errorf("pop key: %w", err)
 	}
 
+	nextKey, err := ctx.SquashedDictionaryManager.LastKey()
+	if err != nil {
+		return fmt.Errorf("get last key: %w", err)
+	}
 	mv := mem.MemoryValueFromFieldElement(&nextKey)
 	return vm.Memory.WriteToAddress(&nextKeyAddr, &mv)
 }

pkg/runner/gas.go

@@ -51,7 +51,7 @@ func gasInitialization(memory *mem.Memory) error {
 		return err
 	}
 
-	preCostTokenTypes := []TokenGasCost{PedersenToken, BitwiseToken, EcOpToken, PoseidonToken, AddModToken, MulModToken}
+	preCostTokenTypes := []TokenGasCost{PedersenToken, PoseidonToken, BitwiseToken, EcOpToken, AddModToken, MulModToken}
 
 	for _, token := range preCostTokenTypes {
 		cost, err := getTokenGasCost(token)

pkg/runner/runner.go

@@ -541,13 +541,47 @@ func GetEntryCodeInstructions(function starknet.EntryPointByFunction, finalizeFo
 	}
 
 	ctx := &InlineCasmContext{}
+
+	gotSegmentArena := false
+	for _, builtin := range function.Builtins {
+		if builtin == builtins.SegmentArenaType {
+			gotSegmentArena = true
+		}
+	}
+
+	hints := make(map[uint64][]hinter.Hinter)
+
+	if gotSegmentArena {
+		hints[uint64(ctx.currentCodeOffset)] = []hinter.Hinter{
+			&core.AllocSegment{
+				Dst: hinter.ApCellRef(0),
+			},
+			&core.AllocSegment{
+				Dst: hinter.ApCellRef(1),
+			},
+		}
+		ctx.AddInlineCASM(
+			"[ap+2] = 0, ap++;",
+		)
+		ctx.AddInlineCASM(
+			"[ap] = [[ap-1]], ap++;",
+		)
+		ctx.AddInlineCASM(
+			`
+			[ap] = [[ap-2]+1], ap++;
+			[ap-1] = [[ap-3]+2];
+			`,
+		)
+		apOffset += 3
+	}
+
 	paramsSize := 0
 	for _, param := range paramTypes {
 		paramsSize += param.Size
 	}
 	apOffset += paramsSize
 	usedArgs := 0
-	var hints map[uint64][]hinter.Hinter
+
 	for _, builtin := range function.Builtins {
 		if offset, isBuiltin := builtinsOffsetsMap[builtin]; isBuiltin {
 			ctx.AddInlineCASM(
@@ -561,10 +595,8 @@ func GetEntryCodeInstructions(function starknet.EntryPointByFunction, finalizeFo
 			)
 			apOffset += 1
 		} else if builtin == builtins.GasBuiltinType {
-			hints = map[uint64][]hinter.Hinter{
-				uint64(ctx.currentCodeOffset): {
-					&core.ExternalWriteArgsToMemory{},
-				},
+			hints[uint64(ctx.currentCodeOffset)] = []hinter.Hinter{
+				&core.ExternalWriteArgsToMemory{},
 			}
 			ctx.AddInlineCASM("ap += 1;")
 			apOffset += 1

pkg/vm/builtins/builtin_runner.go

@@ -25,6 +25,7 @@ const (
 	AddModeType
 	MulModType
 	GasBuiltinType
+	SystemType
 )
 
 func Runner(name BuiltinType) memory.BuiltinRunner {