cairo-lang 0.11.1.1__zip → 0.11.2__zip

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.11.1.1
+Version: 0.11.2
 Summary: Compiler and runner for the Cairo language
 Home-page: https://cairo-lang.org/
 Author: Starkware
@@ -22,7 +22,7 @@ We recommend starting from [Setting up the environment](https://cairo-lang.org/d
 # Installation instructions
 
 You should be able to download the python package zip file directly from
-[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.0.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.2)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -64,7 +64,7 @@ Once the docker image is built, you can fetch the python package zip file using:
 
 ```bash
 > container_id=$(docker create cairo)
-> docker cp ${container_id}:/app/cairo-lang-0.11.1.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.11.2.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/README.md

@@ -12,7 +12,7 @@ We recommend starting from [Setting up the environment](https://cairo-lang.org/d
 # Installation instructions
 
 You should be able to download the python package zip file directly from
-[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.0.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.2)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -54,7 +54,7 @@ Once the docker image is built, you can fetch the python package zip file using:
 
 ```bash
 > container_id=$(docker create cairo)
-> docker cp ${container_id}:/app/cairo-lang-0.11.1.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.11.2.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/cairo_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.11.1.1
+Version: 0.11.2
 Summary: Compiler and runner for the Cairo language
 Home-page: https://cairo-lang.org/
 Author: Starkware
@@ -22,7 +22,7 @@ We recommend starting from [Setting up the environment](https://cairo-lang.org/d
 # Installation instructions
 
 You should be able to download the python package zip file directly from
-[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.0.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.2)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -64,7 +64,7 @@ Once the docker image is built, you can fetch the python package zip file using:
 
 ```bash
 > container_id=$(docker create cairo)
-> docker cp ${container_id}:/app/cairo-lang-0.11.1.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.11.2.zip .
 > docker rm -v ${container_id}
 ```
 

cairo-lang-0.11.2/starkware/cairo/lang/VERSION

@@ -0,0 +1 @@
+0.11.2

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/cairo/lang/create_cairo_lang_zip.py

@@ -10,7 +10,7 @@ import sys
 
 from starkware.python.utils import get_build_dir_path
 
-COMPILER_DIR = get_build_dir_path("../cairo-compiler-archive-1.0.0")
+COMPILER_DIR = get_build_dir_path("../cairo-compiler-archive-1.1.0")
 
 INIT_FILE_CONTENT = "__path__ = __import__('pkgutil').extend_path(__path__, __name__)\n"
 

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/cairo/lang/vm/cairo_pie.py

@@ -4,21 +4,22 @@ A CairoPie represents a position independent execution of a Cairo program.
 
 import copy
 import dataclasses
+import functools
 import io
 import json
 import math
 import zipfile
 from dataclasses import field
-from typing import Any, ClassVar, Dict, List, Type
+from typing import Any, ClassVar, Dict, List, Mapping, Optional, Tuple, Type
 
 import marshmallow
 import marshmallow.fields as mfields
 import marshmallow_dataclass
 
 from starkware.cairo.lang.compiler.program import StrippedProgram, is_valid_builtin_name
-from starkware.cairo.lang.vm.memory_dict import MemoryDict
+from starkware.cairo.lang.vm.memory_dict import MemoryDict, RelocateValueFunc
 from starkware.cairo.lang.vm.memory_segments import is_valid_memory_addr, is_valid_memory_value
-from starkware.cairo.lang.vm.relocatable import RelocatableValue
+from starkware.cairo.lang.vm.relocatable import MaybeRelocatable, RelocatableValue, relocate_value
 from starkware.python.utils import add_counters, multiply_counter_by_scalar, sub_counters
 from starkware.starkware_utils.marshmallow_dataclass_fields import additional_metadata
 
@@ -279,12 +280,68 @@ class CairoPie:
 
         return cls(metadata, memory, additional_data, execution_resources, version)
 
-    def to_file(self, file):
+    def merge_extra_segments(self) -> Tuple[List[SegmentInfo], Dict[int, RelocatableValue]]:
+        """
+        Merges extra_segments to one segment.
+        Returns a tuple of the new extra_segments (which contains a single merged segment) and a
+        dictionary from old segment index to its offset in the new segment.
+        """
+        assert len(self.metadata.extra_segments) > 0
+
+        # Take the index of the segment from the first merged segment.
+        new_segment_index = self.metadata.extra_segments[0].index
+        segment_offsets = {}
+        segments_accumulated_size = 0
+        for segment in self.metadata.extra_segments:
+            segment_offsets[segment.index] = RelocatableValue(
+                new_segment_index, segments_accumulated_size
+            )
+            segments_accumulated_size += segment.size
+        return (
+            [SegmentInfo(index=new_segment_index, size=segments_accumulated_size)],
+            segment_offsets,
+        )
+
+    def get_relocate_value_func(
+        self, segment_offsets: Optional[Mapping[int, MaybeRelocatable]]
+    ) -> Optional[RelocateValueFunc]:
+        """
+        Returns a relocate_value function that relocates values according to the given segment
+        offsets.
+        """
+        if segment_offsets is None:
+            return None
+
+        return functools.partial(
+            relocate_value,
+            segment_offsets=segment_offsets,
+            prime=self.program.prime,
+            # The known segments (such as builtins) are missing since we do not want to relocate
+            # them.
+            allow_missing_segments=True,
+        )
+
+    def to_file(self, file, merge_extra_segments: bool = False):
+        extra_segments, segment_offsets = (
+            self.merge_extra_segments()
+            if merge_extra_segments and len(self.metadata.extra_segments) > 0
+            else (None, None)
+        )
+        metadata = self.metadata
+        if extra_segments is not None:
+            metadata = dataclasses.replace(metadata, extra_segments=extra_segments)
         with zipfile.ZipFile(file, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
             with zf.open(self.METADATA_FILENAME, "w") as fp:
-                fp.write(json.dumps(CairoPieMetadata.Schema().dump(self.metadata)).encode("ascii"))
+                fp.write(json.dumps(CairoPieMetadata.Schema().dump(metadata)).encode("ascii"))
             with zf.open(self.MEMORY_FILENAME, "w") as fp:
-                fp.write(self.memory.serialize(self.metadata.field_bytes))
+                fp.write(
+                    self.memory.serialize(
+                        field_bytes=self.metadata.field_bytes,
+                        relocate_value=self.get_relocate_value_func(
+                            segment_offsets=segment_offsets
+                        ),
+                    )
+                )
             with zf.open(self.ADDITIONAL_DATA_FILENAME, "w") as fp:
                 fp.write(json.dumps(self.additional_data).encode("ascii"))
             with zf.open(self.EXECUTION_RESOURCES_FILENAME, "w") as fp:

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/cairo/lang/vm/memory_dict.py

@@ -32,6 +32,8 @@ MemoryDictInitializer = Optional[
     ]
 ]
 
+RelocateValueFunc = Callable[[MaybeRelocatable], MaybeRelocatable]
+
 
 class MemoryDict:
     """
@@ -213,14 +215,17 @@ class MemoryDict:
         """
         self.data[addr] = value
 
-    def serialize(self, field_bytes):
+    def serialize(self, field_bytes, relocate_value: Optional[RelocateValueFunc] = None):
         assert (
             len(self.relocation_rules) == 0
         ), "Cannot serialize a MemoryDict with active segment relocation rules."
 
+        if relocate_value is None:
+            relocate_value = lambda val: val
+
         return b"".join(
-            RelocatableValue.to_bytes(addr, ADDR_SIZE_IN_BYTES, "little")
-            + RelocatableValue.to_bytes(value, field_bytes, "little")
+            RelocatableValue.to_bytes(relocate_value(addr), ADDR_SIZE_IN_BYTES, "little")
+            + RelocatableValue.to_bytes(relocate_value(value), field_bytes, "little")
             for addr, value in self.items()
         )
 

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/python/utils.py

@@ -168,6 +168,26 @@ def get_source_dir_path(rel_path: str = "", default_value: Optional[str] = None)
     raise Exception(f"Failed to get source path for {rel_path}.")
 
 
+def deduce_absolute_path(path: str) -> str:
+    """
+    Returns the given path if it is absolute, and otherwise joins it with the current working
+    directory.
+    This function is useful when using Bazel, which changes the current working directory.
+
+    Important note: This function assumes that the code is being run using Bazel.
+    """
+
+    if os.path.isabs(path):
+        return path
+
+    # The path is considered to be relative to the current working directory.
+    build_working_directory = os.getenv("BUILD_WORKING_DIRECTORY")
+    assert (
+        build_working_directory is not None
+    ), "Could not deduce your working directory path; please run your code using Bazel."
+    return os.path.join(build_working_directory, path)
+
+
 def assert_same_and_get(*args):
     """
     Verifies that all the arguments are the same, and returns this value.

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/starknet/business_logic/state/state_api_objects.py

@@ -28,7 +28,7 @@ class BlockInfo(ValidatedMarshmallowDataclass):
     # The sequencer address of this block.
     sequencer_address: Optional[int] = field(metadata=fields.optional_sequencer_address_metadata)
 
-    # The version of StarkNet system (e.g. "0.11.1").
+    # The version of Starknet system (e.g. "0.11.2").
     starknet_version: Optional[str] = field(metadata=fields.starknet_version_metadata)
 
     @classmethod

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/starknet/compiler/v1/compile.py

@@ -14,7 +14,7 @@ if "RUNFILES_DIR" in os.environ:
 
     r = runfiles.Create()
 
-    COMPILER_DIR = r.Rlocation("cairo-compiler-archive-1.0.0/bin")
+    COMPILER_DIR = r.Rlocation("cairo-compiler-archive-1.1.0/bin")
 else:
     COMPILER_DIR = os.path.join(os.path.dirname(__file__), "bin")
 

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/starknet/compiler/v1/corelib/src/array.cairo

@@ -60,7 +60,6 @@ impl ArrayImpl<T> of ArrayTrait<T> {
     fn is_empty(self: @Array<T>) -> bool {
         self.len() == 0_usize
     }
-
     #[inline(always)]
     fn span(self: @Array<T>) -> Span<T> {
         Span { snapshot: self }
@@ -104,7 +103,6 @@ impl SpanImpl<T> of SpanTrait<T> {
             Option::None(_) => Option::None(()),
         }
     }
-
     #[inline(always)]
     fn pop_back(ref self: Span<T>) -> Option<@T> {
         let mut snapshot = self.snapshot;
@@ -115,7 +113,6 @@ impl SpanImpl<T> of SpanTrait<T> {
             Option::None(_) => Option::None(()),
         }
     }
-
     #[inline(always)]
     fn get(self: Span<T>, index: usize) -> Option<Box<@T>> {
         array_get(self.snapshot, index)

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/starknet/compiler/v1/corelib/src/debug.cairo

@@ -84,8 +84,8 @@ impl U128PrintImpl of PrintTrait<u128> {
 
 impl U256PrintImpl of PrintTrait<u256> {
     fn print(self: u256) {
-        self.low.into().print();
-        self.high.into().print();
+        Into::<u128, felt252>::into(self.low).print();
+        Into::<u128, felt252>::into(self.high).print();
     }
 }
 

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/starknet/compiler/v1/corelib/src/dict.cairo

@@ -1,5 +1,4 @@
-use traits::Index;
-use traits::Default;
+use traits::{Index, Default};
 
 extern type Felt252Dict<T>;
 extern type SquashedFelt252Dict<T>;
@@ -69,28 +68,41 @@ impl Felt252DictImpl<T, impl TDefault: Felt252DictValue<T>> of Felt252DictTrait<
     }
 }
 
-impl Felt252DictDestruct<T,
-impl TDrop: Drop<T>,
-impl TDefault: Felt252DictValue<T>> of Destruct<Felt252Dict<T>> {
+trait Felt252DictEntryTrait<T> {
+    fn finalize(self: Felt252DictEntry<T>, new_value: T) -> Felt252Dict<T>;
+}
+
+impl Felt252DictEntryImpl<T, impl TDefault: Felt252DictValue<T>> of Felt252DictEntryTrait<T> {
+    #[inline(always)]
+    fn finalize(self: Felt252DictEntry<T>, new_value: T) -> Felt252Dict<T> {
+        felt252_dict_entry_finalize(self, new_value)
+    }
+}
+
+impl Felt252DictDestruct<
+    T, impl TDrop: Drop<T>, impl TDefault: Felt252DictValue<T>
+> of Destruct<Felt252Dict<T>> {
     #[inline(always)]
     fn destruct(self: Felt252Dict<T>) nopanic {
         self.squash();
     }
 }
 
-impl Felt252DictEntryDestruct<T,
-impl TDrop: Drop<T>,
-impl TDefault: Felt252DictValue<T>> of Destruct<Felt252DictEntry<T>> {
+impl Felt252DictEntryDestruct<
+    T, impl TDrop: Drop<T>, impl TDefault: Felt252DictValue<T>
+> of Destruct<Felt252DictEntry<T>> {
     #[inline(always)]
     fn destruct(self: Felt252DictEntry::<T>) nopanic {
         felt252_dict_entry_finalize(self, TDefault::zero_default());
     }
 }
 
-impl Felt252DictIndex<T,
-impl TDictImpl: Felt252DictTrait<T>,
-impl TCopy: Copy<T>,
-impl EntryDestruct: Destruct<Felt252DictEntry<T>>> of Index<Felt252Dict<T>, felt252, T> {
+impl Felt252DictIndex<
+    T,
+    impl TDictImpl: Felt252DictTrait<T>,
+    impl TCopy: Copy<T>,
+    impl EntryDestruct: Destruct<Felt252DictEntry<T>>
+> of Index<Felt252Dict<T>, felt252, T> {
     #[inline(always)]
     fn index(ref self: Felt252Dict<T>, index: felt252) -> T {
         self.get(index)

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/starknet/compiler/v1/corelib/src/ecdsa.cairo

@@ -1,21 +1,10 @@
 use zeroable::IsZeroResult;
-use ec::ec_mul;
-use ec::ec_neg;
-use ec::ec_point_from_x;
-use ec::ec_point_from_x_nz;
-use ec::ec_point_is_zero;
-use ec::ec_point_new;
-use ec::ec_point_new_nz;
-use ec::ec_point_non_zero;
-use ec::ec_point_try_new;
-use ec::ec_point_try_new_nz;
-use ec::ec_point_unwrap;
-use ec::ec_point_zero;
-use ec::ec_state_add_mul;
-use ec::ec_state_add;
-use ec::ec_state_finalize;
-use ec::ec_state_init;
-use ec::ec_state_try_finalize_nz;
+use ec::{
+    ec_mul, ec_neg, ec_point_from_x, ec_point_from_x_nz, ec_point_is_zero, ec_point_new,
+    ec_point_new_nz, ec_point_non_zero, ec_point_try_new, ec_point_try_new_nz, ec_point_unwrap,
+    ec_point_zero, ec_state_add_mul, ec_state_add, ec_state_finalize, ec_state_init,
+    ec_state_try_finalize_nz
+};
 
 // Checks if (`signature_r`, `signature_s`) is a valid ECDSA signature for the given `public_key`
 // on the given `message`.

{cairo-lang-0.11.1.1 → cairo-lang-0.11.2}/starkware/starknet/compiler/v1/corelib/src/hash.cairo

@@ -81,12 +81,14 @@ impl TupleSize1LegacyHash<E0, impl E0LegacyHash: LegacyHash<E0>> of LegacyHash<(
     }
 }
 
-impl TupleSize2LegacyHash<E0,
-E1,
-impl E0LegacyHash: LegacyHash<E0>,
-impl E1LegacyHash: LegacyHash<E1>,
-impl E0Drop: Drop<E0>,
-impl E1Drop: Drop<E1>> of LegacyHash<(E0, E1)> {
+impl TupleSize2LegacyHash<
+    E0,
+    E1,
+    impl E0LegacyHash: LegacyHash<E0>,
+    impl E1LegacyHash: LegacyHash<E1>,
+    impl E0Drop: Drop<E0>,
+    impl E1Drop: Drop<E1>
+> of LegacyHash<(E0, E1)> {
     fn hash(state: felt252, value: (E0, E1, )) -> felt252 {
         let (e0, e1) = value;
         let state = E0LegacyHash::hash(state, e0);
@@ -94,15 +96,16 @@ impl E1Drop: Drop<E1>> of LegacyHash<(E0, E1)> {
     }
 }
 
-impl TupleSize3LegacyHash<E0,
-E1,
-E2,
-impl E0LegacyHash: LegacyHash<E0>,
-impl E1LegacyHash: LegacyHash<E1>,
-impl E2LegacyHash: LegacyHash<E2>,
-impl E0Drop: Drop<E0>,
-impl E1Drop: Drop<E1>,
-impl E2Drop: Drop<E2>,
+impl TupleSize3LegacyHash<
+    E0,
+    E1,
+    E2,
+    impl E0LegacyHash: LegacyHash<E0>,
+    impl E1LegacyHash: LegacyHash<E1>,
+    impl E2LegacyHash: LegacyHash<E2>,
+    impl E0Drop: Drop<E0>,
+    impl E1Drop: Drop<E1>,
+    impl E2Drop: Drop<E2>,
 > of LegacyHash<(E0, E1, E2)> {
     fn hash(state: felt252, value: (E0, E1, E2)) -> felt252 {
         let (e0, e1, e2) = value;
@@ -112,18 +115,19 @@ impl E2Drop: Drop<E2>,
     }
 }
 
-impl TupleSize4LegacyHash<E0,
-E1,
-E2,
-E3,
-impl E0LegacyHash: LegacyHash<E0>,
-impl E1LegacyHash: LegacyHash<E1>,
-impl E2LegacyHash: LegacyHash<E2>,
-impl E3LegacyHash: LegacyHash<E3>,
-impl E0Drop: Drop<E0>,
-impl E1Drop: Drop<E1>,
-impl E2Drop: Drop<E2>,
-impl E3Drop: Drop<E3>,
+impl TupleSize4LegacyHash<
+    E0,
+    E1,
+    E2,
+    E3,
+    impl E0LegacyHash: LegacyHash<E0>,
+    impl E1LegacyHash: LegacyHash<E1>,
+    impl E2LegacyHash: LegacyHash<E2>,
+    impl E3LegacyHash: LegacyHash<E3>,
+    impl E0Drop: Drop<E0>,
+    impl E1Drop: Drop<E1>,
+    impl E2Drop: Drop<E2>,
+    impl E3Drop: Drop<E3>,
 > of LegacyHash<(E0, E1, E2, E3)> {
     fn hash(state: felt252, value: (E0, E1, E2, E3)) -> felt252 {
         let (e0, e1, e2, e3) = value;