cairo-lang 0.13.3__zip → 0.13.4a1__zip

{cairo-lang-0.13.3 → cairo-lang-0.13.4a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.13.3
+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.3)
+[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.3.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.13.3 → 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.3)
+[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.3.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.13.3 → 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.3
+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.3)
+[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.3.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
 > docker rm -v ${container_id}
 ```
 

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

@@ -313,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
@@ -369,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
@@ -476,7 +475,9 @@ 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
@@ -531,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
@@ -554,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.3 → 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.3 → 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.3 → 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.3 → 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/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.3 → 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.3 → 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.3 → 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,
+    )

{cairo-lang-0.13.3 → cairo-lang-0.13.4a1}/starkware/cairo/lang/vm/cairo_run.py

@@ -48,20 +48,26 @@ def main():
     parser.add_argument(
         "--steps",
         type=int,
-        help="The number of instructions to perform. If steps is not given, runs the program until "
-        "the __end__ instruction, and then continues until the number of steps is a power of 2.",
+        help=(
+            "The number of instructions to perform. If steps is not given, runs the program until "
+            "the __end__ instruction, and then continues until the number of steps is a power of 2."
+        ),
     )
     parser.add_argument(
         "--min_steps",
         type=int,
-        help="The minimal number of instructions to perform. This can be used to guarantee that "
-        "there will be enough builtin instances for the program.",
+        help=(
+            "The minimal number of instructions to perform. This can be used to guarantee that "
+            "there will be enough builtin instances for the program."
+        ),
     )
     parser.add_argument(
         "--debug_error",
         action="store_true",
-        help="If there is an error during the execution, stop the execution, but produce the "
-        "partial outputs.",
+        help=(
+            "If there is an error during the execution, stop the execution, but produce the "
+            "partial outputs."
+        ),
     )
     parser.add_argument(
         "--no_end",
@@ -82,8 +88,10 @@ def main():
         "--secure_run",
         action="store_true",
         default=None,
-        help="Verify that the run is secure and can be run safely using the bootloader "
-        "(the default).",
+        help=(
+            "Verify that the run is secure and can be run safely using the bootloader "
+            "(the default)."
+        ),
     )
     parser.add_argument(
         "--no_secure_run",
@@ -119,8 +127,10 @@ def main():
     parser.add_argument(
         "--run_from_cairo_pie",
         type=argparse.FileType("rb"),
-        help="Runs a Cairo PIE file, instead of a program. "
-        "This flag can be used with --secure_run to verify the correctness of a Cairo PIE file.",
+        help=(
+            "Runs a Cairo PIE file, instead of a program. "
+            "This flag can be used with --secure_run to verify the correctness of a Cairo PIE file."
+        ),
     )
     parser.add_argument(
         "--cairo_pie_output",
@@ -160,8 +170,10 @@ def main():
     parser.add_argument(
         "--profile_output",
         type=str,
-        help="A path to an output file to write profile data to. Can be opened in pprof. "
-        'Usually "profile.pb.gz".',
+        help=(
+            "A path to an output file to write profile data to. Can be opened in pprof. "
+            'Usually "profile.pb.gz".'
+        ),
     )
     parser.add_argument(
         "--proof_mode", action="store_true", help="Prepare a provable execution trace."
@@ -316,6 +328,13 @@ def cairo_run(args):
         assert cairo_pie_input is not None
         # Add extra_segments.
         for segment_info in cairo_pie_input.metadata.extra_segments:
+            if (
+                runner.segments.zero_segment is not None
+                and segment_info.index == runner.segments.zero_segment.segment_index
+            ):
+                # If a zero segment is required for the run, don't initialize it again.
+                # It's saved as the first segment in the extra_segments list.
+                continue
             runner.segments.add(size=segment_info.size)
         # Update the builtin runners' additional_data.
         for name, builtin_runner in runner.builtin_runners.items():
@@ -466,9 +485,11 @@ def cairo_run(args):
                         f"--program={args.program.name}",
                         f"--trace={trace_file.name}",
                         f"--memory={memory_file.name}",
-                        f"--air_public_input={args.air_public_input.name}"
-                        if args.air_public_input
-                        else None,
+                        (
+                            f"--air_public_input={args.air_public_input.name}"
+                            if args.air_public_input
+                            else None
+                        ),
                         f"--debug_info={debug_info_file.name}",
                     ],
                 )
@@ -488,9 +509,11 @@ def cairo_run(args):
                         f"--program={args.program.name}",
                         f"--trace={trace_file.name}",
                         f"--memory={memory_file.name}",
-                        f"--air_public_input={args.air_public_input.name}"
-                        if args.air_public_input
-                        else None,
+                        (
+                            f"--air_public_input={args.air_public_input.name}"
+                            if args.air_public_input
+                            else None
+                        ),
                         f"--debug_info={debug_info_file.name}",
                         f"--profile_output={args.profile_output}",
                     ],

{cairo-lang-0.13.3 → cairo-lang-0.13.4a1}/starkware/cairo/lang/vm/vm_core.py

@@ -473,6 +473,7 @@ class VirtualMachine(VirtualMachineBase):
             exec_locals.update(self.static_locals)
             exec_locals["builtin_runners"] = self.builtin_runners
             exec_locals.update(self.builtin_runners)
+            exec_locals["iter_accessed_addresses"] = lambda: iter(self.accessed_addresses)
 
             self.exec_hint(hint.compiled, exec_locals, hint_index=hint_index)
 
@@ -490,6 +491,7 @@ class VirtualMachine(VirtualMachineBase):
             del exec_locals["vm_load_program"]
             del exec_locals["ids"]
             del exec_locals["memory"]
+            del exec_locals["iter_accessed_addresses"]
 
             if self.skip_instruction_execution:
                 return

{cairo-lang-0.13.3 → cairo-lang-0.13.4a1}/starkware/python/math_utils.py

@@ -1,5 +1,6 @@
 import math
 import random
+from functools import lru_cache
 from hashlib import sha256
 from typing import List, Optional, Tuple, Union
 
@@ -339,6 +340,36 @@ def fft(coeffs: List[int], generator: int, prime: int, bit_reversed: bool = Fals
     if bit_reversed:
         width = coeffs_len.bit_length() - 1
         perm = [int("{:0{width}b}".format(i, width=width)[::-1], 2) for i in range(coeffs_len)]
-        return [values[i] for i in perm]
+        values = [values[i] for i in perm]
 
     return values
+
+
+def ifft(
+    coeffs: List[int], generator: int, prime: int, coeffs_bit_reversed: bool = False
+) -> List[int]:
+    """
+    Computes the inverse FFT of `coeffs`, assuming the size of the coefficient array is a power of
+    two and equals to the generator's multiplicative order.
+    """
+    # Use the modular multiplicative inverse of the generator.
+    inv_generator = pow_cached(generator, prime - 2, prime)
+
+    coeffs_len = len(coeffs)
+
+    if coeffs_bit_reversed:
+        # Permutate back the coefficients.
+        width = coeffs_len.bit_length() - 1
+        perm = [int("{:0{width}b}".format(i, width=width)[::-1], 2) for i in range(coeffs_len)]
+        coeffs = [coeffs[i] for i in perm]
+
+    values = fft(coeffs=coeffs, generator=inv_generator, prime=prime, bit_reversed=False)
+
+    # Normalize the result by dividing each coefficient by the length of the array.
+    coeffs_len_inv = pow_cached(coeffs_len, prime - 2, prime)
+    return [(value * coeffs_len_inv) % prime for value in values]
+
+
+@lru_cache()
+def pow_cached(base: int, exp: int, mod: int) -> int:
+    return pow(base=base, exp=exp, mod=mod)

{cairo-lang-0.13.3 → cairo-lang-0.13.4a1}/starkware/starknet/business_logic/execution/deprecated_objects.py

@@ -176,6 +176,8 @@ class DeprecatedCallInfo(SerializableMarshmallowDataclass):
             l2_to_l1_messages=[message.to_non_deprecated() for message in self.l2_to_l1_messages],
             storage_read_values=self.storage_read_values,
             accessed_storage_keys=self.accessed_storage_keys,
+            read_class_hash_values=[],
+            accessed_contract_addresses=set(),
             internal_calls=[
                 internal_call.to_non_deprecated() for internal_call in self.internal_calls
             ],

{cairo-lang-0.13.3 → cairo-lang-0.13.4a1}/starkware/starknet/business_logic/execution/execute_entry_point.py

@@ -41,7 +41,7 @@ from starkware.starknet.core.os.deprecated_syscall_handler import DeprecatedBlSy
 from starkware.starknet.core.os.syscall_handler import BusinessLogicSyscallHandler
 from starkware.starknet.definitions import fields
 from starkware.starknet.definitions.constants import VERSIONED_CONSTANTS, GasCost
-from starkware.starknet.definitions.error_codes import StarknetErrorCode
+from starkware.starknet.definitions.error_codes import CairoErrorCode, StarknetErrorCode
 from starkware.starknet.definitions.execution_mode import ExecutionMode
 from starkware.starknet.definitions.general_config import (
     STARKNET_LAYOUT_INSTANCE,
@@ -106,7 +106,7 @@ class ExecuteEntryPoint(ExecuteEntryPointBase):
         entry_point_selector: int,
         entry_point_type: Optional[EntryPointType] = None,
         caller_address: int = 0,
-        initial_gas: int = GasCost.INITIAL.value,
+        initial_gas: int = GasCost.DEFAULT_INITIAL.value,
         call_type: Optional[CallType] = None,
         class_hash: Optional[int] = None,
     ) -> "ExecuteEntryPoint":
@@ -266,7 +266,34 @@ class ExecuteEntryPoint(ExecuteEntryPointBase):
             )
 
         # Prepare implicit arguments.
-        implicit_args = os_utils.prepare_os_implicit_args(runner=runner, gas=self.initial_gas)
+        initial_gas_call = self.initial_gas - GasCost.ENTRY_POINT_INITIAL_BUDGET.value
+        if initial_gas_call < 0:
+            return CallInfo.create(
+                # Execution params.
+                caller_address=self.caller_address,
+                call_type=self.call_type,
+                contract_address=self.contract_address,
+                code_address=self.code_address,
+                class_hash=class_hash,
+                entry_point_selector=self.entry_point_selector,
+                entry_point_type=self.entry_point_type,
+                calldata=self.calldata,
+                # Execution results.
+                gas_consumed=0,
+                failure_flag=1,
+                retdata=[CairoErrorCode.OUT_OF_GAS.to_felt()],
+                execution_resources=ExecutionResources.empty(),
+                events=[],
+                l2_to_l1_messages=[],
+                # Necessary info. for the OS run.
+                storage_read_values=[],
+                accessed_storage_keys=set(),
+                # Internal calls.
+                internal_calls=[],
+                accessed_contract_addresses=set(),
+                read_class_hash_values=[],
+            )
+        implicit_args = os_utils.prepare_os_implicit_args(runner=runner, gas=initial_gas_call)
 
         # Prepare syscall handler.
         initial_syscall_ptr = cast(RelocatableValue, implicit_args[-1])
@@ -480,6 +507,8 @@ class ExecuteEntryPoint(ExecuteEntryPointBase):
             accessed_storage_keys=storage.accessed_keys if storage is not None else set(),
             # Internal calls.
             internal_calls=internal_calls,
+            accessed_contract_addresses=set(),
+            read_class_hash_values=[],
         )
 
     def _get_non_optional_class_hash(