Implement DictWrite hint

integration_tests/cairo_files/dict.cairo

@@ -0,0 +1,67 @@
+from starkware.cairo.common.default_dict import default_dict_new
+from starkware.cairo.common.dict import dict_read, dict_write
+from starkware.cairo.common.dict_access import DictAccess
+
+func test_default_dict() {
+    alloc_locals;
+    let (local my_dict: DictAccess*) = default_dict_new(123);
+
+    return ();
+}
+
+func test_read() {
+    alloc_locals;
+    let (local my_dict: DictAccess*) = default_dict_new(123);
+
+    let (local val1: felt) = dict_read{dict_ptr=my_dict}(key=1);
+    assert val1 = 123;
+
+    let (local val2: felt) = dict_read{dict_ptr=my_dict}(key=2);
+    assert val2 = 123;
+
+    return ();
+}
+
+func test_write() {
+    alloc_locals;
+    let (local my_dict: DictAccess*) = default_dict_new(123);
+
+    let (local val1: felt) = dict_read{dict_ptr=my_dict}(key=1);
+    assert val1 = 123;
+
+    let (local val2: felt) = dict_read{dict_ptr=my_dict}(key=2);
+    assert val2 = 123;
+
+    dict_write{dict_ptr=my_dict}(key=1, new_value=512);
+    let (local val3: felt) = dict_read{dict_ptr=my_dict}(key=1);
+    assert val3 = 512;
+
+    let (local val4: felt) = dict_read{dict_ptr=my_dict}(key=2);
+    assert val4 = 123;
+
+    dict_write{dict_ptr=my_dict}(key=1, new_value=1024);
+    let (local val5: felt) = dict_read{dict_ptr=my_dict}(key=1);
+    assert val5 = 1024;
+
+    let (local val6: felt) = dict_read{dict_ptr=my_dict}(key=2);
+    assert val6 = 123;
+
+    dict_write{dict_ptr=my_dict}(key=1, new_value=888);
+    dict_write{dict_ptr=my_dict}(key=2, new_value=999);
+    let (local val7: felt) = dict_read{dict_ptr=my_dict}(key=1);
+    assert val7 = 888;
+    let (local val8: felt) = dict_read{dict_ptr=my_dict}(key=2);
+    assert val8 = 999;
+    let (local val9: felt) = dict_read{dict_ptr=my_dict}(key=3);
+    assert val9 = 123;
+
+    return ();
+}
+
+func main() {
+    test_default_dict();
+    test_read();
+    test_write();
+
+    return ();
+}

pkg/hintrunner/hinter/scope.go

@@ -98,3 +98,12 @@ func (sm *ScopeManager) getCurrentScope() (*map[string]any, error) {
 	}
 	return &sm.scopes[len(sm.scopes)-1], nil
 }
+
+func (sm *ScopeManager) GetZeroDictionaryManager() (ZeroDictionaryManager, bool) {
+	dictionaryManagerValue, err := sm.GetVariableValue("__dict_manager")
+	if err != nil {
+		return ZeroDictionaryManager{}, false
+	}
+	dictionaryManager, ok := dictionaryManagerValue.(ZeroDictionaryManager)
+	return dictionaryManager, ok
+}

pkg/hintrunner/hinter/zero_dict.go

@@ -0,0 +1,116 @@
+package hinter
+
+import (
+	"fmt"
+
+	VM "github.com/NethermindEth/cairo-vm-go/pkg/vm"
+	mem "github.com/NethermindEth/cairo-vm-go/pkg/vm/memory"
+	f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
+)
+
+// Used to keep track of all dictionaries data
+type ZeroDictionary struct {
+	// The data contained on a dictionary
+	data map[f.Element]mem.MemoryValue
+	// Default value for key not present in the dictionary
+	defaultValue mem.MemoryValue
+	// first free offset in memory segment of dictionary
+	freeOffset uint64
+}
+
+// Gets the memory value at certain key
+func (d *ZeroDictionary) At(key f.Element) (mem.MemoryValue, error) {
+	if value, ok := d.data[key]; ok {
+		return value, nil
+	}
+	if d.defaultValue != mem.UnknownValue {
+		return d.defaultValue, nil
+	}
+	return mem.UnknownValue, fmt.Errorf("no value for key: %v", key)
+}
+
+// Given a key and a value, it sets the value at the given key
+func (d *ZeroDictionary) Set(key f.Element, value mem.MemoryValue) {
+	d.data[key] = value
+}
+
+// Given a incrementBy value, it increments the freeOffset field of dictionary by it
+func (d *ZeroDictionary) IncrementFreeOffset(freeOffset uint64) {
+	d.freeOffset += freeOffset
+}
+
+// Used to manage dictionaries creation
+type ZeroDictionaryManager struct {
+	// a map that links a segment index to a dictionary
+	dictionaries map[uint64]ZeroDictionary
+}
+
+func NewZeroDictionaryManager() ZeroDictionaryManager {
+	return ZeroDictionaryManager{
+		dictionaries: make(map[uint64]ZeroDictionary),
+	}
+}
+
+// It creates a new segment which will hold dictionary values. It links this
+// segment with the current dictionary and returns the address that points
+// to the start of this segment
+func (dm *ZeroDictionaryManager) NewDictionary(vm *VM.VirtualMachine) mem.MemoryAddress {
+	newDictAddr := vm.Memory.AllocateEmptySegment()
+	dm.dictionaries[newDictAddr.SegmentIndex] = ZeroDictionary{
+		data:         make(map[f.Element]mem.MemoryValue),
+		defaultValue: mem.UnknownValue,
+		freeOffset:   0,
+	}
+	return newDictAddr
+}
+
+// It creates a new segment which will hold dictionary values. It links this
+// segment with the current dictionary and returns the address that points
+// to the start of this segment. If key not present in the dictionary during
+// querying the defaultValue will be returned instead.
+func (dm *ZeroDictionaryManager) NewDefaultDictionary(vm *VM.VirtualMachine, defaultValue mem.MemoryValue) mem.MemoryAddress {
+	newDefaultDictAddr := vm.Memory.AllocateEmptySegment()
+	dm.dictionaries[newDefaultDictAddr.SegmentIndex] = ZeroDictionary{
+		data:         make(map[f.Element]mem.MemoryValue),
+		defaultValue: defaultValue,
+		freeOffset:   0,
+	}
+	return newDefaultDictAddr
+}
+
+// Given a memory address, it looks for the right dictionary using the segment index. If no
+// segment is associated with the given segment index, it errors
+func (dm *ZeroDictionaryManager) GetDictionary(dictAddr mem.MemoryAddress) (ZeroDictionary, error) {
+	dict, ok := dm.dictionaries[dictAddr.SegmentIndex]
+	if ok {
+		return dict, nil
+	}
+	return ZeroDictionary{}, fmt.Errorf("no dictionary at address: %s", dictAddr)
+}
+
+// Given a memory address and a key it returns the value held at that position. The address is used
+// to locate the correct dictionary and the key to index on it
+func (dm *ZeroDictionaryManager) At(dictAddr mem.MemoryAddress, key f.Element) (mem.MemoryValue, error) {
+	if dict, ok := dm.dictionaries[dictAddr.SegmentIndex]; ok {
+		return dict.At(key)
+	}
+	return mem.UnknownValue, fmt.Errorf("no dictionary at address: %s", dictAddr)
+}
+
+// Given a memory address,a key and a value it stores the value at the correct position.
+func (dm *ZeroDictionaryManager) Set(dictAddr mem.MemoryAddress, key f.Element, value mem.MemoryValue) error {
+	if dict, ok := dm.dictionaries[dictAddr.SegmentIndex]; ok {
+		dict.Set(key, value)
+		return nil
+	}
+	return fmt.Errorf("no dictionary at address: %s", dictAddr)
+}
+
+// Given a memory address and a incrementBy, it increments the freeOffset field of dictionary by it.
+func (dm *ZeroDictionaryManager) IncrementFreeOffset(dictAddr mem.MemoryAddress, freeOffset uint64) error {
+	if dict, ok := dm.dictionaries[dictAddr.SegmentIndex]; ok {
+		dict.IncrementFreeOffset(freeOffset)
+		return nil
+	}
+	return fmt.Errorf("no dictionary at address: %s", dictAddr)
+}

pkg/hintrunner/zero/hintcode.go

@@ -108,6 +108,9 @@ const (
 	keccakWriteArgs string = "segments.write_arg(ids.inputs, [ids.low % 2 ** 64, ids.low // 2 ** 64])\nsegments.write_arg(ids.inputs + 2, [ids.high % 2 ** 64, ids.high // 2 ** 64])"
 
 	// ------ Dictionaries hints related code ------
+	defaultDictNewCode           string = "if '__dict_manager' not in globals():\n    from starkware.cairo.common.dict import DictManager\n    __dict_manager = DictManager()\n\nmemory[ap] = __dict_manager.new_default_dict(segments, ids.default_value)"
+	dictReadCode                 string = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.value = dict_tracker.data[ids.key]"
+	dictWriteCode                string = "dict_tracker = __dict_manager.get_tracker(ids.dict_ptr)\ndict_tracker.current_ptr += ids.DictAccess.SIZE\nids.dict_ptr.prev_value = dict_tracker.data[ids.key]\ndict_tracker.data[ids.key] = ids.new_value"
 	squashDictInnerAssertLenKeys string = "assert len(keys) == 0"
 	squashDictInnerNextKey       string = "assert len(keys) > 0, 'No keys left but remaining_accesses > 0.'\nids.next_key = key = keys.pop()"
 

pkg/hintrunner/zero/zerohint.go

@@ -157,6 +157,12 @@ func GetHintFromCode(program *zero.ZeroProgram, rawHint zero.Hint, hintPC uint64
 	case usortBodyCode:
 		return createUsortBodyHinter(resolver)
 		// Dictionaries hints
+	case defaultDictNewCode:
+		return createDefaultDictNewHinter(resolver)
+	case dictReadCode:
+		return createDictReadHinter(resolver)
+	case dictWriteCode:
+		return createDictWriteHinter(resolver)
 	case squashDictInnerAssertLenKeys:
 		return createSquashDictInnerAssertLenKeysHinter()
 	case squashDictInnerNextKey: