cairo-lang 0.13.2a0__zip → 0.13.4a1__zip

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.13.2a0
+Version: 0.13.4a1
 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.13.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.13.4)
 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.13.2.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/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.13.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.13.4)
 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.13.2.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/cairo_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.13.2a0
+Version: 0.13.4a1
 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.13.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.13.4)
 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.13.2.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/cairo_lang.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ starkware/cairo/common/bitwise.cairo
 starkware/cairo/common/bool.cairo
 starkware/cairo/common/cairo_builtins.cairo
 starkware/cairo/common/cairo_function_runner.py
+starkware/cairo/common/copy_indices.cairo
 starkware/cairo/common/default_dict.cairo
 starkware/cairo/common/dict.cairo
 starkware/cairo/common/dict.py
@@ -64,6 +65,7 @@ starkware/cairo/common/hash_state_poseidon.cairo
 starkware/cairo/common/invoke.cairo
 starkware/cairo/common/keccak.cairo
 starkware/cairo/common/keccak_state.cairo
+starkware/cairo/common/log2_ceil.cairo
 starkware/cairo/common/math.cairo
 starkware/cairo/common/math_cmp.cairo
 starkware/cairo/common/math_utils.py
@@ -311,8 +313,6 @@ starkware/python/object_utils.py
 starkware/python/python_dependencies.py
 starkware/python/utils.py
 starkware/python/utils_stub_module.py
-starkware/solidity/__init__.py
-starkware/solidity/utils.py
 starkware/starknet/__init__.py
 starkware/starknet/builtins/__init__.py
 starkware/starknet/builtins/segment_arena/__init__.py
@@ -367,6 +367,7 @@ starkware/starknet/compiler/validation_utils.py
 starkware/starknet/compiler/v1/__init__.py
 starkware/starknet/compiler/v1/compile.py
 starkware/starknet/compiler/v1/compiler_exe_paths.py
+starkware/starknet/compiler/v1/experimental_libfuncs.json
 starkware/starknet/compiler/v1/mainnet_libfuncs.json
 starkware/starknet/compiler/v1/testnet_libfuncs.json
 starkware/starknet/compiler/v1/sierra-compiler-major-1/bin/starknet-compile
@@ -428,11 +429,19 @@ starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/starknet/stor
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/starknet/syscalls.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/starknet/testing.cairo
 starkware/starknet/core/__init__.py
+starkware/starknet/core/aggregator/__init__.py
+starkware/starknet/core/aggregator/output_parser.py
+starkware/starknet/core/aggregator/utils.py
 starkware/starknet/core/os/__init__.py
+starkware/starknet/core/os/block_context.cairo
+starkware/starknet/core/os/builtins.cairo
+starkware/starknet/core/os/constants.cairo
 starkware/starknet/core/os/deprecated_syscall_handler.py
 starkware/starknet/core/os/kzg_manager.py
+starkware/starknet/core/os/os.cairo
 starkware/starknet/core/os/os_logger.py
 starkware/starknet/core/os/os_utils.py
+starkware/starknet/core/os/output.cairo
 starkware/starknet/core/os/segment_utils.py
 starkware/starknet/core/os/starknet_builtins.json
 starkware/starknet/core/os/starknet_new_syscalls.json
@@ -455,8 +464,27 @@ starkware/starknet/core/os/contract_class/contract_class.cairo
 starkware/starknet/core/os/contract_class/deprecated_class_hash.py
 starkware/starknet/core/os/contract_class/deprecated_compiled_class.cairo
 starkware/starknet/core/os/contract_class/utils.py
+starkware/starknet/core/os/data_availability/__init__.py
+starkware/starknet/core/os/data_availability/bls_field.cairo
+starkware/starknet/core/os/data_availability/bls_utils.py
+starkware/starknet/core/os/data_availability/commitment.cairo
+starkware/starknet/core/os/data_availability/compression.cairo
+starkware/starknet/core/os/data_availability/compression.py
+starkware/starknet/core/os/execution/deprecated_execute_entry_point.cairo
+starkware/starknet/core/os/execution/deprecated_execute_syscalls.cairo
+starkware/starknet/core/os/execution/execute_entry_point.cairo
+starkware/starknet/core/os/execution/execute_syscalls.cairo
+starkware/starknet/core/os/execution/execute_transactions.cairo
+starkware/starknet/core/os/execution/revert.cairo
+starkware/starknet/core/os/os_config/os_config.cairo
+starkware/starknet/core/os/state/aliases.cairo
+starkware/starknet/core/os/state/commitment.cairo
+starkware/starknet/core/os/state/output.cairo
+starkware/starknet/core/os/state/squash.cairo
+starkware/starknet/core/os/state/state.cairo
 starkware/starknet/core/os/transaction_hash/__init__.py
 starkware/starknet/core/os/transaction_hash/deprecated_transaction_hash.py
+starkware/starknet/core/os/transaction_hash/transaction_hash.cairo
 starkware/starknet/core/os/transaction_hash/transaction_hash.py
 starkware/starknet/core/test_contract/__init__.py
 starkware/starknet/core/test_contract/delegate_proxy.json
@@ -473,6 +501,7 @@ starkware/starknet/definitions/fields.py
 starkware/starknet/definitions/general_config.py
 starkware/starknet/definitions/general_config.yml
 starkware/starknet/definitions/l1_da_mode.py
+starkware/starknet/definitions/overridable_versioned_constants.py
 starkware/starknet/definitions/transaction_type.py
 starkware/starknet/definitions/versioned_constants.json
 starkware/starknet/public/__init__.py
@@ -503,7 +532,6 @@ starkware/starknet/security/whitelists/uint256_improvements.json
 starkware/starknet/security/whitelists/vrf.json
 starkware/starknet/services/__init__.py
 starkware/starknet/services/api/__init__.py
-starkware/starknet/services/api/messages.py
 starkware/starknet/services/api/contract_class/__init__.py
 starkware/starknet/services/api/contract_class/contract_class.py
 starkware/starknet/services/api/contract_class/contract_class_utils.py
@@ -526,16 +554,6 @@ starkware/starknet/services/utils/__init__.py
 starkware/starknet/services/utils/sequencer_api_utils.py
 starkware/starknet/storage/__init__.py
 starkware/starknet/storage/starknet_storage.py
-starkware/starknet/testing/MockStarknetMessaging.json
-starkware/starknet/testing/__init__.py
-starkware/starknet/testing/contract.py
-starkware/starknet/testing/contract_utils.py
-starkware/starknet/testing/contracts.py
-starkware/starknet/testing/objects.py
-starkware/starknet/testing/postman.py
-starkware/starknet/testing/starknet.py
-starkware/starknet/testing/state.py
-starkware/starknet/testing/test_utils.py
 starkware/starknet/third_party/__init__.py
 starkware/starknet/third_party/open_zeppelin/__init__.py
 starkware/starknet/third_party/open_zeppelin/account.json

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/cairo_lang.egg-info/requires.txt

@@ -7,7 +7,7 @@ fastecdsa
 frozendict
 gprof2dot
 lark
-marshmallow-dataclass>=7.1.0
+marshmallow-dataclass==8.6.1
 marshmallow-enum
 marshmallow-oneofschema
 marshmallow>=3.2.1

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/requirements.txt

@@ -7,7 +7,7 @@ fastecdsa
 frozendict
 gprof2dot
 lark
-marshmallow-dataclass>=7.1.0
+marshmallow-dataclass==8.6.1
 marshmallow-enum
 marshmallow-oneofschema
 marshmallow>=3.2.1

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/setup.py

@@ -44,7 +44,6 @@ setuptools.setup(
         "starkware.starknet.core.os": ["*/*.cairo", "*.cairo", "*.json"],
         "starkware.starknet.core.test_contract": ["*.cairo", "*.json"],
         "starkware.starknet.security": ["whitelists/*.json"],
-        "starkware.starknet.testing": ["*.json"],
         "starkware.starknet.third_party.open_zeppelin": ["account.json"],
     },
     scripts=[

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/bootloaders/fact_topology.py

@@ -6,6 +6,10 @@ import marshmallow
 import marshmallow_dataclass
 
 GPS_FACT_TOPOLOGY = "gps_fact_topology"
+# A limit on the page size (in words) we allow, which is derived from MAX_ETHEREUM_TX_SIZE
+# with some "safty" buffer.
+# Output page sizes are set by clients and therefore this limit should not be decreased
+# without prior coordination, since it may fail jobs set based on the previous limit.
 MAX_PAGE_SIZE = 3800
 
 
@@ -23,6 +27,24 @@ class FactTopology:
         assert page0_size <= MAX_PAGE_SIZE, "Page size exceeded the maximum."
         return cls(tree_structure=[1, 0], page_sizes=[page0_size])
 
+    def get_output_size(self) -> int:
+        """
+        Returns the size of the output, in words. This is the sum of the sizes of all pages.
+        """
+        return sum(self.page_sizes)
+
+    def get_fact_tree_structure_len(self) -> int:
+        """
+        Returns the total length of the fact tree structure.
+        """
+        return len(self.tree_structure)
+
+    def get_n_pages(self) -> int:
+        """
+        Returns the number of pages in the fact topology.
+        """
+        return len(self.page_sizes)
+
 
 @marshmallow_dataclass.dataclass(frozen=True)
 class FactTopologiesFile:
@@ -80,13 +102,17 @@ def get_page_sizes_from_page_dict(output_size: int, pages: dict) -> List[int]:
         expected_page_id += 1
 
     if len(pages) > 0:
-        assert expected_page_start == output_size, "Pages must cover the entire program output."
+        assert expected_page_start == output_size, (
+            "Pages must cover the entire program output."
+            + f" Expected size of {expected_page_start}, found {output_size}."
+        )
 
     return [page0_size] + [page_size for _, (_, page_size) in sorted(pages.items())]
 
 
 def get_fact_topology_from_additional_data(
-    output_size: int, output_builtin_additional_data: Dict[str, Any]
+    output_size: int,
+    output_builtin_additional_data: Dict[str, Any],
 ) -> FactTopology:
     """
     Returns the fact topology from the additional data of the output builtin.

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/bootloaders/generate_fact.py

@@ -35,7 +35,9 @@ def get_program_output(cairo_pie: CairoPie) -> List[int]:
 
 
 def get_cairo_pie_fact_info(
-    cairo_pie: CairoPie, program_hash: Optional[int] = None, aggregator: bool = False
+    cairo_pie: CairoPie,
+    program_hash: Optional[int] = None,
+    aggregator: bool = False,
 ) -> FactInfo:
     """
     Generates the fact of the Cairo program of cairo_pie. Returns the cairo-pie fact info.

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/common/cairo_sha256/sha256_utils.cairo

@@ -480,7 +480,7 @@ func finalize_sha256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(
             sha2_compress_function,
         )
 
-        number_of_missing_blocks = -ids.n % ids.BATCH_SIZE
+        number_of_missing_blocks = (-ids.n) % ids.BATCH_SIZE
         assert 0 <= number_of_missing_blocks < 20
         _sha256_input_chunk_size_felts = ids.SHA256_INPUT_CHUNK_SIZE_FELTS
         assert 0 <= _sha256_input_chunk_size_felts < 100
@@ -488,7 +488,7 @@ func finalize_sha256{range_check_ptr, bitwise_ptr: BitwiseBuiltin*}(
         message = [0] * _sha256_input_chunk_size_felts
         w = compute_message_schedule(message)
         output = sha2_compress_function(IV, w)
-        padding = (message + IV + output) * (number_of_missing_blocks)
+        padding = (message + IV + output) * number_of_missing_blocks
         segments.write_arg(ids.sha256_ptr_end, padding)
     %}
 

cairo-lang-0.13.4a1/starkware/cairo/common/copy_indices.cairo

@@ -0,0 +1,36 @@
+// Copies len field elements from src to dst at the given indices.
+// I.e., dst = [src[i] for i in indices].
+func copy_indices(dst: felt*, src: felt*, indices: felt*, len: felt) {
+    struct LoopFrame {
+        dst: felt*,
+        indices: felt*,
+    }
+
+    if (len == 0) {
+        return ();
+    }
+
+    %{ vm_enter_scope({'n': ids.len}) %}
+    tempvar frame = LoopFrame(dst=dst, indices=indices);
+
+    loop:
+    let frame = [cast(ap - LoopFrame.SIZE, LoopFrame*)];
+    assert [frame.dst] = src[[frame.indices]];
+
+    let continue_copying = [ap];
+    // Reserve space for continue_copying.
+    let next_frame = cast(ap + 1, LoopFrame*);
+    next_frame.dst = frame.dst + 1, ap++;
+    next_frame.indices = frame.indices + 1, ap++;
+    %{
+        n -= 1
+        ids.continue_copying = 1 if n > 0 else 0
+    %}
+    static_assert next_frame + LoopFrame.SIZE == ap + 1;
+    jmp loop if continue_copying != 0, ap++;
+    // Assert that the loop executed len times.
+    len = cast(next_frame.indices, felt) - cast(indices, felt);
+
+    %{ vm_exit_scope() %}
+    return ();
+}

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/common/ec.cairo

@@ -137,6 +137,7 @@ func ec_op{ec_op_ptr: EcOpBuiltin*}(p: EcPoint, m: felt, q: EcPoint) -> (r: EcPo
         seed = b"".join(map(to_bytes, [ids.p.x, ids.p.y, ids.m, ids.q.x, ids.q.y]))
         ids.s.x, ids.s.y = random_ec_point(FIELD_PRIME, ALPHA, BETA, seed)
     %}
+    assert_on_curve(s);
     let p_plus_s: EcPoint = ec_add(p, s);
 
     assert ec_op_ptr.p = p_plus_s;
@@ -217,6 +218,7 @@ func chained_ec_op{ec_op_ptr: EcOpBuiltin*}(p: EcPoint, m: felt*, q: EcPoint*, l
         )
         ids.s.x, ids.s.y = random_ec_point(FIELD_PRIME, ALPHA, BETA, seed)
     %}
+    assert_on_curve(s);
     let p_plus_s: EcPoint = ec_add(p, s);
     let r_plus_s: EcPoint = _chained_ec_op_inner(p=p_plus_s, m=m, q=q, len=len);
     let r: EcPoint = ec_add(r_plus_s, EcPoint(x=s.x, y=-s.y));

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/common/hash_state_poseidon.cairo

@@ -22,7 +22,7 @@ func hash_init() -> HashState {
 
 // Adds a single item to the HashState.
 func hash_update_single{hash_state: HashState}(item: felt) {
-    tempvar current_end = hash_state.end;
+    let current_end = hash_state.end;
     assert [current_end] = item;
     let hash_state = HashState(start=hash_state.start, end=current_end + 1);
     return ();
@@ -30,8 +30,7 @@ func hash_update_single{hash_state: HashState}(item: felt) {
 
 // Adds each element in the array to the HashState.
 func hash_update{hash_state: HashState}(data_ptr: felt*, data_length: felt) {
-    alloc_locals;
-    tempvar current_end = hash_state.end;
+    let current_end = hash_state.end;
     memcpy(dst=current_end, src=data_ptr, len=data_length);
     let hash_state = HashState(start=hash_state.start, end=current_end + data_length);
     return ();

cairo-lang-0.13.4a1/starkware/cairo/common/log2_ceil.cairo

@@ -0,0 +1,28 @@
+from starkware.cairo.common.math import assert_in_range, assert_not_zero
+from starkware.cairo.common.pow import pow
+
+// Returns the ceil value of the log2 of the given value.
+// Enforces that 1 <= value <= RANGE_CHECK_BOUND.
+func log2_ceil{range_check_ptr}(value: felt) -> felt {
+    alloc_locals;
+    assert_not_zero(value);
+    if (value == 1) {
+        return 0;
+    }
+
+    local res;
+    %{
+        from starkware.python.math_utils import log2_ceil
+        ids.res = log2_ceil(ids.value)
+    %}
+
+    // Verify that 1 <= 2**(res - 1) < value <= 2**res <= RANGE_CHECK_BOUND.
+    // The RANGE_CHECK_BOUND bound is required by the `assert_in_range` function.
+    assert_in_range(res, 1, 128 + 1);
+    let (lower_bound) = pow(2, res - 1);
+    let min = lower_bound + 1;
+    let max = 2 * lower_bound;
+    assert_in_range(value, min, max + 1);
+
+    return res;
+}

cairo-lang-0.13.4a1/starkware/cairo/common/modulo.cairo

@@ -0,0 +1,47 @@
+from starkware.cairo.common.cairo_builtins import ModBuiltin, UInt384
+from starkware.cairo.common.math import safe_div, unsigned_div_rem
+from starkware.cairo.common.registers import get_label_location
+
+const BATCH_SIZE = 1;
+
+// Fills the first instance of the add_mod and mul_mod builtins and calls the fill_memory hint to
+// fill the rest of the instances and the missing values in the values table.
+//
+// This function uses a hardcoded value of batch_size=1, and asserts the instance definitions use
+// the same value.
+func run_mod_p_circuit{add_mod_ptr: ModBuiltin*, mul_mod_ptr: ModBuiltin*}(
+    p: UInt384,
+    values_ptr: UInt384*,
+    add_mod_offsets_ptr: felt*,
+    add_mod_n: felt,
+    mul_mod_offsets_ptr: felt*,
+    mul_mod_n: felt,
+) {
+    if (add_mod_n != 0) {
+        assert add_mod_ptr[0] = ModBuiltin(
+            p=p, values_ptr=values_ptr, offsets_ptr=add_mod_offsets_ptr, n=add_mod_n
+        );
+    }
+
+    if (mul_mod_n != 0) {
+        assert mul_mod_ptr[0] = ModBuiltin(
+            p=p, values_ptr=values_ptr, offsets_ptr=mul_mod_offsets_ptr, n=mul_mod_n
+        );
+    }
+
+    %{
+        from starkware.cairo.lang.builtins.modulo.mod_builtin_runner import ModBuiltinRunner
+        assert builtin_runners["add_mod_builtin"].instance_def.batch_size == 1
+        assert builtin_runners["mul_mod_builtin"].instance_def.batch_size == 1
+
+        ModBuiltinRunner.fill_memory(
+            memory=memory,
+            add_mod=(ids.add_mod_ptr.address_, builtin_runners["add_mod_builtin"], ids.add_mod_n),
+            mul_mod=(ids.mul_mod_ptr.address_, builtin_runners["mul_mod_builtin"], ids.mul_mod_n),
+        )
+    %}
+
+    let add_mod_ptr = &add_mod_ptr[add_mod_n];
+    let mul_mod_ptr = &mul_mod_ptr[mul_mod_n];
+    return ();
+}

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/common/secp256r1/ec.cairo

@@ -33,8 +33,8 @@ func compute_doubling_slope{range_check_ptr}(point: EcPoint) -> (slope: BigInt3)
         from starkware.python.math_utils import ec_double_slope
 
         # Compute the slope.
-        x = pack(ids.point.x, SECP256R1_P)
-        y = pack(ids.point.y, SECP256R1_P)
+        x = pack(ids.point.x, PRIME)
+        y = pack(ids.point.y, PRIME)
         value = slope = ec_double_slope(point=(x, y), alpha=SECP256R1_ALPHA, p=SECP256R1_P)
     %}
     let (slope: BigInt3) = nondet_bigint3();
@@ -126,9 +126,9 @@ func ec_double{range_check_ptr}(point: EcPoint) -> (res: EcPoint) {
         from starkware.cairo.common.cairo_secp.secp256r1_utils import SECP256R1_P
         from starkware.cairo.common.cairo_secp.secp_utils import pack
 
-        slope = pack(ids.slope, SECP256R1_P)
-        x = pack(ids.point.x, SECP256R1_P)
-        y = pack(ids.point.y, SECP256R1_P)
+        slope = pack(ids.slope, PRIME)
+        x = pack(ids.point.x, PRIME)
+        y = pack(ids.point.y, PRIME)
 
         value = new_x = (pow(slope, 2, SECP256R1_P) - 2 * x) % SECP256R1_P
     %}
@@ -373,7 +373,7 @@ func try_get_point_from_x{range_check_ptr}(x: BigInt3, v: felt, result: EcPoint*
         from starkware.python.math_utils import y_squared_from_x
 
         y_square_int = y_squared_from_x(
-            x=pack(ids.x, SECP256R1.prime),
+            x=pack(ids.x, PRIME),
             alpha=SECP256R1.alpha,
             beta=SECP256R1.beta,
             field_prime=SECP256R1.prime,

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/common/squash_dict.cairo

@@ -2,8 +2,8 @@ from starkware.cairo.common.dict_access import DictAccess
 from starkware.cairo.common.math import assert_lt_felt
 
 // Verifies that dict_accesses lists valid chronological accesses (and updates)
-// to a mutable dictionary and outputs a squashed dict with one DictAccess instance per key
-// (value before and value after) which summarizes all the changes to that key.
+// to a mutable dictionary and outputs a squashed dict, sorted by key, with one DictAccess instance
+// per key (value before and value after) which summarizes all the changes to that key.
 //
 // Example:
 //   Input: {(key1, 0, 2), (key1, 2, 7), (key2, 4, 1), (key1, 7, 5), (key2, 1, 2)}

cairo-lang-0.13.4a1/starkware/cairo/lang/VERSION

@@ -0,0 +1 @@
+0.13.4a1

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/lang/builtins/modulo/mod_builtin_runner.py

@@ -129,13 +129,6 @@ class ModBuiltinRunner(SimpleBuiltinRunnerWithLowRatio):
     def finalize_segments(self, runner):
         super().finalize_segments(runner)
 
-    def get_additional_data(self):
-        assert self.zero_value is not None, "Uninitialized self.zero_value."
-        return [list(RelocatableValue.to_tuple(self.zero_value))]
-
-    def extend_additional_data(self, data, relocate_callback, data_is_trusted=True):
-        self.zero_value = relocate_callback(RelocatableValue.from_tuple(data[0]))
-
     # The structure of the values in the returned dictionary is of the form:
     # {keys = INPUT_NAMES, "batch": {index_in_batch: {keys = MEMORY_VAR_NAMES}}}.
     def air_private_input(self, runner) -> Dict[str, Any]:

{cairo-lang-0.13.2a0 → cairo-lang-0.13.4a1}/starkware/cairo/lang/dynamic_layout_params.py

@@ -1,4 +1,5 @@
 import dataclasses
+from fractions import Fraction
 from typing import Dict, Optional
 
 from starkware.cairo.lang.builtins.all_builtins import (
@@ -11,13 +12,26 @@ from starkware.cairo.lang.builtins.instance_def import (
     BuiltinInstanceDefWithLowRatio,
 )
 from starkware.cairo.lang.instances import COMPONENT_HEIGHT, CairoLayout, build_dynamic_layout
-from starkware.python.math_utils import safe_div
+from starkware.python.math_utils import safe_div, safe_log2
 
 MAX_CPU_COMPONENT_STEP = 2**8
 MIN_MEMORY_UNITS_PER_STEP = 4
 NUM_COLUMNS_FIRST_BOUND = 2**16
 NUM_COLUMNS_SECOND_BOUND = 2**16
 
+ROW_RATIO_NAMES = {
+    "pedersen": "pedersen_builtin_row_ratio",
+    "range_check": "range_check_builtin_row_ratio",
+    "ecdsa": "ecdsa_builtin_row_ratio",
+    "bitwise": "bitwise__row_ratio",
+    "ec_op": "ec_op_builtin_row_ratio",
+    "keccak": "keccak__row_ratio",
+    "poseidon": "poseidon__row_ratio",
+    "range_check96": "range_check96_builtin_row_ratio",
+    "add_mod": "add_mod__row_ratio",
+    "mul_mod": "mul_mod__row_ratio",
+}
+
 
 @dataclasses.dataclass(frozen=True)
 class CairoLayoutParams:
@@ -132,3 +146,54 @@ class CairoLayoutParams:
             memory_units_per_step=self.memory_units_per_step,
             **builtin_ratios,
         )
+
+
+def dynamic_params_dict_to_cairo_layout_params(
+    dynamic_params_dict: Dict[str, int]
+) -> CairoLayoutParams:
+    """
+    Creates a CairoLayoutParams object from a dynamic params dictionary.
+    """
+    builtins_params_dict: Dict[str, int] = {}
+    for builtin_name, row_ratio_name in ROW_RATIO_NAMES.items():
+        uses_builtin_str = f"uses_{builtin_name}_builtin"
+        builtin_ratio_str = f"{builtin_name}_ratio"
+        builtins_params_dict[uses_builtin_str] = dynamic_params_dict[uses_builtin_str]
+        if builtin_name in LOW_RATIO_BUILTINS:
+            builtins_params_dict[builtin_ratio_str + "_den"] = 1
+        if builtins_params_dict[uses_builtin_str] == 1:
+            # The builtin ratio can be calculated from the row_ratio as the fraction
+            # `row_ratio / (COMPONENT_HEIGHT * cpu_component_step)`. After reduction, this fraction
+            # must be in the form of either `ratio / 1` (in the general case) or `1 / ratio_den`
+            # (only for low-ratio builtins).
+            ratio_frac = Fraction(
+                dynamic_params_dict[row_ratio_name],
+                COMPONENT_HEIGHT * dynamic_params_dict["cpu_component_step"],
+            )
+            if ratio_frac.denominator != 1:
+                assert ratio_frac.numerator == 1
+                assert builtin_name in LOW_RATIO_BUILTINS
+                builtins_params_dict[builtin_ratio_str] = 1
+                builtins_params_dict[builtin_ratio_str + "_den"] = ratio_frac.denominator
+            else:
+                builtins_params_dict[builtin_ratio_str] = ratio_frac.numerator
+
+        else:
+            builtins_params_dict[builtin_ratio_str] = 0
+
+    log_diluted_units_per_step = safe_log2(
+        COMPONENT_HEIGHT * dynamic_params_dict["cpu_component_step"]
+    ) - safe_log2(dynamic_params_dict["diluted_units_row_ratio"])
+    return CairoLayoutParams(
+        cpu_component_step=dynamic_params_dict["cpu_component_step"],
+        rc_units=safe_div(
+            COMPONENT_HEIGHT * dynamic_params_dict["cpu_component_step"],
+            dynamic_params_dict["range_check_units_row_ratio"],
+        ),
+        memory_units_per_step=safe_div(
+            COMPONENT_HEIGHT * dynamic_params_dict["cpu_component_step"],
+            dynamic_params_dict["memory_units_row_ratio"],
+        ),
+        log_diluted_units_per_step=log_diluted_units_per_step,
+        **builtins_params_dict,
+    )