Implement all SQUASH_DICT+ hints

cairo_programs/dict_squash.cairo

@@ -0,0 +1,29 @@
+%builtins range_check
+
+from starkware.cairo.common.dict_access import DictAccess
+from starkware.cairo.common.dict import dict_write, dict_update, dict_squash
+from starkware.cairo.common.default_dict import default_dict_new
+
+func main{range_check_ptr}() -> () {
+    let (dict_start) = default_dict_new(17);
+    let dict_end = dict_start;
+    dict_write{dict_ptr=dict_end}(0, 1);
+    dict_write{dict_ptr=dict_end}(1, 10);
+    dict_write{dict_ptr=dict_end}(2, -2);
+    dict_update{dict_ptr=dict_end}(0, 1, 2);
+    dict_update{dict_ptr=dict_end}(0, 2, 3);
+    dict_update{dict_ptr=dict_end}(0, 3, 4);
+    dict_update{dict_ptr=dict_end}(1, 10, 15);
+    dict_update{dict_ptr=dict_end}(1, 15, 20);
+    dict_update{dict_ptr=dict_end}(1, 20, 25);
+    dict_update{dict_ptr=dict_end}(2, -2, -4);
+    dict_update{dict_ptr=dict_end}(2, -4, -8);
+    dict_update{dict_ptr=dict_end}(2, -8, -16);
+    let (squashed_dict_start, squashed_dict_end) = dict_squash{range_check_ptr=range_check_ptr}(
+        dict_start, dict_end
+    );
+    assert squashed_dict_end[0] = DictAccess(key=0, prev_value=1, new_value=4);
+    assert squashed_dict_end[1] = DictAccess(key=1, prev_value=10, new_value=25);
+    assert squashed_dict_end[2] = DictAccess(key=2, prev_value=-2, new_value=-16);
+    return ();
+}

cairo_programs/squash_dict.cairo

@@ -0,0 +1,33 @@
+%builtins range_check
+
+from starkware.cairo.common.squash_dict import squash_dict
+from starkware.cairo.common.alloc import alloc
+from starkware.cairo.common.dict_access import DictAccess
+
+func main{range_check_ptr}() -> () {
+    alloc_locals;
+    let (dict_start: DictAccess*) = alloc();
+    assert dict_start[0] = DictAccess(key=0, prev_value=100, new_value=100);
+    assert dict_start[1] = DictAccess(key=1, prev_value=50, new_value=50);
+    assert dict_start[2] = DictAccess(key=0, prev_value=100, new_value=200);
+    assert dict_start[3] = DictAccess(key=1, prev_value=50, new_value=100);
+    assert dict_start[4] = DictAccess(key=0, prev_value=200, new_value=300);
+    assert dict_start[5] = DictAccess(key=1, prev_value=100, new_value=150);
+
+    let dict_end = dict_start + 6 * DictAccess.SIZE;
+    // (dict_start, dict_end) now represents the dictionary
+    // {0: 100, 1: 50, 0: 200, 1: 100, 0: 300, 1: 150}.
+
+    // Squash the dictionary from an array of 6 DictAccess structs
+    // to an array of 2, with a single DictAccess entry per key.
+    let (local squashed_dict_start: DictAccess*) = alloc();
+    let (squashed_dict_end) = squash_dict{range_check_ptr=range_check_ptr}(
+        dict_start, dict_end, squashed_dict_start
+    );
+
+    // Check the values of the squashed_dict
+    // should be: {0: (100, 300), 1: (50, 150)}
+    assert squashed_dict_start[0] = DictAccess(key=0, prev_value=100, new_value=300);
+    assert squashed_dict_start[1] = DictAccess(key=1, prev_value=50, new_value=150);
+    return ();
+}

go.mod

@@ -5,6 +5,7 @@ go 1.20
 require (
 	github.com/pkg/errors v0.9.1
 	golang.org/x/crypto v0.12.0
+	golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc
 )
 
 require (

go.sum

@@ -11,4 +11,9 @@ github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6S
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
 golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU=
+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

pkg/hints/dict_hints.go

@@ -141,3 +141,70 @@ func dictUpdate(ids IdsManager, scopes *ExecutionScopes, vm *VirtualMachine) err
 	tracker.CurrentPtr.Offset += DICT_ACCESS_SIZE
 	return nil
 }
+
+func dictSquashCopyDict(ids IdsManager, scopes *ExecutionScopes, vm *VirtualMachine) error {
+	// Extract Variables
+	dictManager, ok := FetchDictManager(scopes)
+	if !ok {
+		return errors.New("Variable __dict_manager not present in current execution scope")
+	}
+	dictAccessEnd, err := ids.GetRelocatable("dict_accesses_end", vm)
+	if err != nil {
+		return err
+	}
+	// Hint logic
+	tracker, err := dictManager.GetTracker(dictAccessEnd)
+	if err != nil {
+		return err
+	}
+	initialDict := tracker.CopyDictionary()
+	scopes.EnterScope(map[string]interface{}{
+		"__dict_manager": dictManager,
+		"initial_dict":   initialDict,
+	})
+	return nil
+}
+
+func dictSquashUpdatePtr(ids IdsManager, scopes *ExecutionScopes, vm *VirtualMachine) error {
+	// Extract Variables
+	dictManager, ok := FetchDictManager(scopes)
+	if !ok {
+		return errors.New("Variable __dict_manager not present in current execution scope")
+	}
+	squashedDictStart, err := ids.GetRelocatable("squashed_dict_start", vm)
+	if err != nil {
+		return err
+	}
+	squashedDictEnd, err := ids.GetRelocatable("squashed_dict_end", vm)
+	if err != nil {
+		return err
+	}
+	// Hint logic
+	tracker, err := dictManager.GetTracker(squashedDictStart)
+	if err != nil {
+		return err
+	}
+	tracker.CurrentPtr = squashedDictEnd
+	return nil
+}
+
+func dictNew(ids IdsManager, scopes *ExecutionScopes, vm *VirtualMachine) error {
+	// Fetch scope variables
+	initialDictAny, err := scopes.Get("initial_dict")
+	if err != nil {
+		return err
+	}
+	initialDict, ok := initialDictAny.(map[memory.MaybeRelocatable]memory.MaybeRelocatable)
+	if !ok {
+		return errors.New("initial_dict not in scope")
+	}
+	// Hint Logic
+	dictManager, ok := FetchDictManager(scopes)
+	if !ok {
+		newDictManager := NewDictManager()
+		dictManager = &newDictManager
+		scopes.AssignOrUpdateVariable("__dict_manager", dictManager)
+	}
+	dict_ptr := dictManager.NewDictionary(&initialDict, vm)
+	return vm.Segments.Memory.Insert(vm.RunContext.Ap, memory.NewMaybeRelocatableRelocatable(dict_ptr))
+}