cairo-lang 0.14.0a1__zip → 0.14.0.1__zip

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.14.0a1
+Version: 0.14.0.1
 Summary: Compiler and runner for the Cairo language
 Home-page: https://cairo-lang.org/
 Author: Starkware

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/cairo_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.14.0a1
+Version: 0.14.0.1
 Summary: Compiler and runner for the Cairo language
 Home-page: https://cairo-lang.org/
 Author: Starkware

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/cairo_lang.egg-info/SOURCES.txt

@@ -441,15 +441,11 @@ starkware/starknet/core/aggregator/output_parser.py
 starkware/starknet/core/aggregator/utils.py
 starkware/starknet/core/os/__init__.py
 starkware/starknet/core/os/bl_syscall_handler.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_bl_syscall_handler.py
 starkware/starknet/core/os/deprecated_syscall_handler.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
@@ -464,39 +460,16 @@ starkware/starknet/core/os/contract_address/contract_address.py
 starkware/starknet/core/os/contract_class/__init__.py
 starkware/starknet/core/os/contract_class/class_hash.py
 starkware/starknet/core/os/contract_class/class_hash_utils.py
-starkware/starknet/core/os/contract_class/compiled_class.cairo
 starkware/starknet/core/os/contract_class/compiled_class_hash.py
 starkware/starknet/core/os/contract_class/compiled_class_hash_objects.py
-starkware/starknet/core/os/contract_class/compiled_class_hash_utils.py
-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/__init__.py
-starkware/starknet/core/os/execution/account_backward_compatibility.cairo
 starkware/starknet/core/os/execution/account_backward_compatibility.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_transaction_utils.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
@@ -610,4 +583,5 @@ starkware/storage/gated_storage.py
 starkware/storage/metrics.py
 starkware/storage/names.py
 starkware/storage/storage.py
+starkware/storage/storage_conflict.py
 starkware/storage/storage_utils.py

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/cairo/bootloaders/generate_fact.py

@@ -37,12 +37,15 @@ def get_program_output(cairo_pie: CairoPie) -> List[int]:
 def get_cairo_pie_fact_info(
     cairo_pie: CairoPie,
     program_hash: Optional[int] = None,
+    program_output: Optional[List[int]] = None,
     aggregator: bool = False,
 ) -> FactInfo:
     """
     Generates the fact of the Cairo program of cairo_pie. Returns the cairo-pie fact info.
     """
-    program_output = get_program_output(cairo_pie=cairo_pie)
+    if program_output is None:
+        program_output = get_program_output(cairo_pie=cairo_pie)
+
     fact_topology = get_fact_topology_from_additional_data(
         output_size=len(program_output),
         output_builtin_additional_data=cairo_pie.additional_data["output_builtin"],

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/cairo/bootloaders/hash_program.py

@@ -2,6 +2,7 @@ import argparse
 import json
 from enum import Enum
 
+from starkware.cairo.common.cairo_blake2s.blake2s_utils import calculate_blake2s_hash_from_felt252s
 from starkware.cairo.common.hash_chain import compute_hash_chain
 from starkware.cairo.lang.compiler.program import Program, ProgramBase
 from starkware.cairo.lang.version import __version__
@@ -20,10 +21,17 @@ class HashFunction(Enum):
 
 
 def compute_program_hash_chain(
-    program: ProgramBase, program_hash_function: HashFunction, bootloader_version=0
+    program: ProgramBase,
+    program_hash_function: HashFunction,
+    bootloader_version=0,
+    encode_blake2s_input: bool = False,
+    little_endian_for_blake2s: bool = True,
 ):
     """
     Computes a hash chain over a program, including the length of the data chain.
+    If `encode_blake2s_input` is True, the data chain is encoded according to the specification
+    documented inside the `calculate_blake2s_hash_from_felt252s` function.
+    If `little_endian_for_blake2s` is True, the blake input is encoded in little-endian u32s.
     """
     builtin_list = [from_bytes(builtin.encode("ascii")) for builtin in program.builtins]
     # The program header below is missing the data length, which is later added to the data_chain.
@@ -36,7 +44,12 @@ def compute_program_hash_chain(
         return compute_hash_chain([len(data_chain)] + data_chain)
     else:
         assert program_hash_function == HashFunction.BLAKE
-        return 0x123456789
+        return calculate_blake2s_hash_from_felt252s(
+            data=data_chain,
+            encode=encode_blake2s_input,
+            little_endian=little_endian_for_blake2s,
+            prime=program.prime,
+        )
 
 
 def main():

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/cairo/common/cairo_blake2s/blake2s.cairo

@@ -667,7 +667,6 @@ const BLAKE2S_FINALIZE_INSTRUCTION = OFF_MINUS_1 * COUNTER_OFFSET + OFF_MINUS_3
     OPCODE_EXT_OFFSET;
 
 // Computes blake2s of `input` of size `len` felts, representing 32 bits each.
-// Note: this function guarantees that len > 0.
 func blake_with_opcode{range_check_ptr}(len: felt, data: felt*, out: felt*) {
     alloc_locals;
 
@@ -682,8 +681,16 @@ func blake_with_opcode{range_check_ptr}(len: felt, data: felt*, out: felt*) {
     assert state[7] = 0x5BE0CD19;
 
     // Express the length in bytes, subtract the remainder for finalize.
-    let (_, rem) = unsigned_div_rem(len - 1, 16);
-    local rem = rem + 1;
+    local rem;
+    if (len == 0) {
+        assert rem = 0;
+        tempvar range_check_ptr = range_check_ptr;
+    } else {
+        let (_, r) = unsigned_div_rem(len - 1, 16);
+        assert rem = r + 1;
+        tempvar range_check_ptr = range_check_ptr;
+    }
+
     local len_in_bytes = (len - rem) * 4;
 
     local range_check_ptr = range_check_ptr;
@@ -731,8 +738,8 @@ func blake_with_opcode{range_check_ptr}(len: felt, data: felt*, out: felt*) {
 
 // Given `data_len` felt252s at `data`, encodes them as u32s as defined in `encode_felt252_to_u32s`
 // and computes the blake2s hash of the result using the dedicated opcodes.
-// The result is then returned as a 224-bit felt, ignoring the last 32 bits.
-func encode_felt252_data_and_calc_224_bit_blake_hash{range_check_ptr: felt}(
+// The 256 bit result is then returned as a felt252 (i.e. modulo PRIME).
+func encode_felt252_data_and_calc_blake_hash{range_check_ptr: felt}(
     data_len: felt, data: felt*
 ) -> (hash: felt) {
     alloc_locals;
@@ -743,8 +750,8 @@ func encode_felt252_data_and_calc_224_bit_blake_hash{range_check_ptr: felt}(
     let (local blake_output: felt*) = alloc();
     blake_with_opcode(len=encoded_data_len, data=encoded_data, out=blake_output);
     return (
-        hash=blake_output[6] * 2 ** 192 + blake_output[5] * 2 ** 160 + blake_output[4] * 2 ** 128 +
-        blake_output[3] * 2 ** 96 + blake_output[2] * 2 ** 64 + blake_output[1] * 2 ** 32 +
-        blake_output[0],
+        hash=blake_output[7] * 2 ** 224 + blake_output[6] * 2 ** 192 + blake_output[5] * 2 ** 160 +
+        blake_output[4] * 2 ** 128 + blake_output[3] * 2 ** 96 + blake_output[2] * 2 ** 64 +
+        blake_output[1] * 2 ** 32 + blake_output[0],
     );
 }

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/cairo/common/cairo_blake2s/blake2s_utils.py

@@ -3,6 +3,8 @@ from typing import List, Tuple
 from starkware.cairo.lang.vm.memory_segments import MemorySegmentManager
 from starkware.cairo.lang.vm.relocatable import RelocatableValue
 
+PRIME = 2**251 + 17 * 2**192 + 1
+
 IV = [
     0x6A09E667,
     0xBB67AE85,
@@ -108,3 +110,75 @@ def mix(a: int, b: int, c: int, d: int, m0: int, m1: int) -> Tuple[int, int, int
     b = right_rot((b ^ c), 7)
 
     return a, b, c, d
+
+
+def blake_state_into_felt(state: List[int], prime: int = PRIME) -> int:
+    digest_int = 0
+    for idx, word in enumerate(state):
+        digest_int |= (word & 0xFFFFFFFF) << (32 * idx)
+
+    return digest_int % prime
+
+
+def calculate_blake2s_hash_from_felt252s(
+    data: List[int], encode: bool, little_endian: bool, prime: int = PRIME
+) -> int:
+    """
+    Converts a list of Felt252s to the BLAKE2s input format and returns the BLAKE2s hash as
+    a single Felt252 (combining the final state words into a 256 bit number and taking it
+    modulo prime).
+
+    • Each field element in `data` is reduced mod `prime`.
+    • When `encode` is True, values < 2**63 are encoded in 2 32-bit words;
+      otherwise they are encoded in 8 words with the 255-bit flag set.
+      If `encode` is False, the 255-bit flag is not set, and all values are
+      taken as 8 words.
+    • When `little_endian` is True, the input is treated as little-endian.
+    • The data stream is fed into `blake2s_compress` in 64-byte blocks (16 words).
+    • `t0` is the running byte counter; `t1 = 0`, `f1 = 0`.
+    • The final block is padded with zeros and flagged by `f0 = 0xffffffff`.
+    """
+    POW2_63 = 1 << 63
+    POW2_255 = 1 << 255
+
+    words: List[int] = []
+    for felt in data:
+        val = felt % prime
+        word_cnt = 2 if encode and val < POW2_63 else 8
+        if encode and word_cnt == 8:
+            val += POW2_255  # Set the 255-bit flag.
+        shifts = range(0, 32 * word_cnt, 32)
+        if not little_endian:
+            shifts = reversed(shifts)
+        for shift in shifts:
+            words.append((val >> shift) & 0xFFFFFFFF)
+
+    state: List[int] = [
+        0x6B08E647,
+        0xBB67AE85,
+        0x3C6EF372,
+        0xA54FF53A,
+        0x510E527F,
+        0x9B05688C,
+        0x1F83D9AB,
+        0x5BE0CD19,
+    ]
+    total_bytes = len(words) * 4
+    bytes_seen = 0
+
+    for i in range(0, max(len(words), 1), 16):
+        block = words[i : i + 16]
+        if len(block) < 16:
+            block += [0] * (16 - len(block))
+        bytes_seen += min(64, total_bytes - bytes_seen)
+        f0 = 0xFFFFFFFF if bytes_seen == total_bytes else 0
+        state = blake2s_compress(
+            h=state,
+            message=block,
+            t0=bytes_seen,
+            t1=0,
+            f0=f0,
+            f1=0,
+        )
+
+    return blake_state_into_felt(state=state, prime=prime)

cairo-lang-0.14.0.1/starkware/cairo/common/hash_state.py

@@ -0,0 +1,60 @@
+import dataclasses
+import functools
+from typing import Callable, List
+
+from starkware.cairo.lang.vm.crypto import pedersen_hash
+
+
+def compute_hash_on_elements(data, hash_func=pedersen_hash):
+    """
+    Computes a hash chain over the data, in the following order:
+        h(h(h(h(0, data[0]), data[1]), ...), data[n-1]), n).
+
+    The hash is initialized with 0 and ends with the data length appended.
+    The length is appended in order to avoid collisions of the following kind:
+    H([x,y,z]) = h(h(x,y),z) = H([w, z]) where w = h(x,y).
+    """
+    return functools.reduce(lambda x, y: hash_func(x, y), [*data, len(data)], 0)
+
+
+def compute_hash_on_elements_without_length(data, hash_func=pedersen_hash):
+    """
+    Similar to `compute_hash_on_elements` but without appending the length.
+    May be used for hashing a prefix of a hash chain.
+    """
+    return functools.reduce(lambda x, y: hash_func(x, y), data, 0)
+
+
+@dataclasses.dataclass
+class HashState:
+    """
+    Class to mimic behavior of the Cairo0 `HashState` struct.
+    """
+
+    current_hash: int
+    n_words: int
+    hash_func: Callable[[int, int], int]
+    finalized: bool
+
+    @classmethod
+    def init(cls, hash_func: Callable[[int, int], int] = pedersen_hash) -> "HashState":
+        return cls(current_hash=0, n_words=0, hash_func=hash_func, finalized=False)
+
+    def update_single(self, value: int):
+        assert not self.finalized, "Cannot update a finalized HashState."
+        self.current_hash = self.hash_func(self.current_hash, value)
+        self.n_words += 1
+
+    def update_with_hashchain(self, values: List[int]):
+        assert not self.finalized, "Cannot update a finalized HashState."
+        n = len(values)
+        data_hash = 0
+        # If the data is empty, we update the hash with h(0, 0).
+        for x in values:
+            data_hash = self.hash_func(data_hash, x)
+        self.update_single(value=self.hash_func(data_hash, n))
+
+    def finalize(self) -> int:
+        assert not self.finalized, "Cannot finalize twice."
+        self.finalized = True
+        return self.hash_func(self.current_hash, self.n_words)

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/cairo/common/math.cairo

@@ -17,6 +17,16 @@ func assert_not_zero(value) {
     return ();
 }
 
+// Verifies that ptr != nullptr. The proof will fail otherwise.
+func assert_not_nullptr(ptr: felt*) {
+    if (ptr == 0) {
+        // If ptr == 0, add an unsatisfiable requirement.
+        ptr = 1;
+    }
+
+    return ();
+}
+
 // Verifies that a != b. The proof will fail otherwise.
 func assert_not_equal(a, b) {
     %{

cairo-lang-0.14.0.1/starkware/cairo/lang/VERSION

@@ -0,0 +1 @@
+0.14.0.1

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/cairo/lang/compiler/cairo_compile.py

@@ -379,6 +379,25 @@ def cairo_assemble_program(
     return program
 
 
+def cairo_compile_wrapper(args: argparse.Namespace):
+    """
+    Wraps cairo_compile_common with the default pass manager and the assembler.
+    """
+
+    def pass_manager_factory(args: argparse.Namespace, module_reader: ModuleReader) -> PassManager:
+        return default_pass_manager(
+            prime=args.prime,
+            read_module=module_reader.read,
+            opt_unused_functions=args.opt_unused_functions,
+        )
+
+    cairo_compile_common(
+        args=args,
+        pass_manager_factory=pass_manager_factory,
+        assemble_func=cairo_assemble_program,
+    )
+
+
 def main():
     parser = argparse.ArgumentParser(description="A tool to compile Cairo code.")
     parser.add_argument(
@@ -395,21 +414,10 @@ def main():
         help="Disable proof mode (see --proof_mode).",
     )
 
-    def pass_manager_factory(args: argparse.Namespace, module_reader: ModuleReader) -> PassManager:
-        return default_pass_manager(
-            prime=args.prime,
-            read_module=module_reader.read,
-            opt_unused_functions=args.opt_unused_functions,
-        )
-
     try:
         cairo_compile_add_common_args(parser)
         args = parser.parse_args()
-        cairo_compile_common(
-            args=args,
-            pass_manager_factory=pass_manager_factory,
-            assemble_func=cairo_assemble_program,
-        )
+        cairo_compile_wrapper(args=args)
     except LocationError as err:
         print(err, file=sys.stderr)
         return 1

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/starknet/business_logic/execution/objects.py

@@ -331,6 +331,11 @@ class CallExecution(ValidatedDataclass):
     # Note that the order starts from a transaction-global offset.
     events: List[OrderedEvent]
     l2_to_l1_messages: List[OrderedL2ToL1Message]
+    cairo_native: bool = field(
+        metadata=additional_metadata(
+            marshmallow_field=mfields.Boolean(required=False, load_default=False)
+        )
+    )
     failed: bool
     gas_consumed: int
 
@@ -419,6 +424,16 @@ class CallInfo(SerializableMarshmallowDataclass):
 
     storage_access_tracker: StorageAccessTracker
 
+    builtin_counters: Dict[str, int] = field(
+        metadata=additional_metadata(
+            marshmallow_field=mfields.Dict(
+                keys=mfields.String,
+                values=mfields.Integer(validate=validate_non_negative("Builtin Counter")),
+                load_default=dict,
+            ),
+        )
+    )
+
     @marshmallow.pre_load
     def from_explicit_storage_access_tracker(
         cls, data: Dict[str, Any], many: bool, **kwargs
@@ -475,6 +490,7 @@ class CallInfo(SerializableMarshmallowDataclass):
             retdata=retdata,
             events=events,
             l2_to_l1_messages=l2_to_l1_messages,
+            cairo_native=False,
             failed=failure_flag != 0,
             gas_consumed=gas_consumed,
         )
@@ -494,6 +510,7 @@ class CallInfo(SerializableMarshmallowDataclass):
             resources=execution_resources,
             storage_access_tracker=storage_access_tracker,
             inner_calls=internal_calls,
+            builtin_counters=dict(),
             tracked_resource=TrackedResource.CairoSteps,
         )
 
@@ -545,6 +562,10 @@ class CallInfo(SerializableMarshmallowDataclass):
     def l2_to_l1_messages(self) -> List[OrderedL2ToL1Message]:
         return self.execution.l2_to_l1_messages
 
+    @property
+    def cairo_native(self) -> int:
+        return self.execution.cairo_native
+
     @property
     def failure_flag(self) -> int:
         return self.execution.failed

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/starknet/compiler/v1/mainnet_libfuncs.json

@@ -25,6 +25,8 @@
         "bounded_int_is_zero",
         "bounded_int_mul",
         "bounded_int_sub",
+        "bounded_int_trim_max",
+        "bounded_int_trim_min",
         "bounded_int_wrap_non_zero",
         "box_forward_snapshot",
         "branch_align",
@@ -126,6 +128,8 @@
         "i8_try_from_felt252",
         "i8_wide_mul",
         "init_circuit_data",
+        "int_range_pop_front",
+        "int_range_try_new",
         "into_box",
         "into_u96_guarantee",
         "jump",

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/starknet/core/aggregator/utils.py

@@ -1,11 +1,19 @@
 import dataclasses
+import os
 from typing import Dict, List
 
 from starkware.cairo.lang.vm.memory_segments import MemorySegmentManager
 from starkware.cairo.lang.vm.relocatable import MaybeRelocatable, RelocatableValue
 from starkware.python.math_utils import safe_div
+from starkware.python.utils import get_source_dir_path
 from starkware.starknet.core.aggregator.output_parser import OsOutput
 
+AGGREGATOR_PROGRAM_HASH_RELATIVE_PATH = "src/starkware/starknet/core/aggregator/program_hash.json"
+AGGREGATOR_PROGRAM_HASH_PATH = get_source_dir_path(
+    AGGREGATOR_PROGRAM_HASH_RELATIVE_PATH,
+    default_value=os.path.join(os.path.dirname(__file__), "program_hash.json"),
+)
+
 
 @dataclasses.dataclass
 class StateEntryManager:

{cairo-lang-0.14.0a1 → cairo-lang-0.14.0.1}/starkware/starknet/core/os/constants.cairo

@@ -16,7 +16,7 @@ const ENTRY_POINT_TYPE_L1_HANDLER = 1;
 const ENTRY_POINT_TYPE_CONSTRUCTOR = 2;
 
 const L1_HANDLER_VERSION = 0;
-const L1_HANDLER_L2_GAS_MAX_AMOUNT = 1000000;
+const L1_HANDLER_L2_GAS_MAX_AMOUNT = 100000000;
 
 // Upper bound on the number of elements in a Sierra array.
 const SIERRA_ARRAY_LEN_BOUND = 4294967296;  // 2^32
@@ -56,11 +56,11 @@ const DEFAULT_ENTRY_POINT_SELECTOR = 0x0;
 // OS reserved contract addresses.
 
 // This contract stores the block number -> block hash mapping.
-const BLOCK_HASH_CONTRACT_ADDRESS = 1;
+const BLOCK_HASH_CONTRACT_ADDRESS = 0x1;
 // This contract stores the aliases mapping used for stateful compression.
-const ALIAS_CONTRACT_ADDRESS = 2;
+const ALIAS_CONTRACT_ADDRESS = 0x2;
 // Future reserved contract address.
-const RESERVED_CONTRACT_ADDRESS = 3;
+const RESERVED_CONTRACT_ADDRESS = 0x3;
 // The block number -> block hash mapping is written for the current block number minus this number.
 const STORED_BLOCK_HASH_BUFFER = 10;
 
@@ -79,7 +79,7 @@ const MUL_MOD_GAS_COST = 604;
 const ECDSA_GAS_COST = 10561;
 const MEMORY_HOLE_GAS_COST = 10;
 
-const DEFAULT_INITIAL_GAS_COST = 100000000 * STEP_GAS_COST;
+const DEFAULT_INITIAL_GAS_COST = 10000000000;
 const VALIDATE_MAX_SIERRA_GAS = 100000000;
 const EXECUTE_MAX_SIERRA_GAS = 1000000000;
 const DEFAULT_INITIAL_GAS_COST_NO_L2 = VALIDATE_MAX_SIERRA_GAS + EXECUTE_MAX_SIERRA_GAS;
@@ -88,45 +88,42 @@ const DEFAULT_INITIAL_GAS_COST_NO_L2 = VALIDATE_MAX_SIERRA_GAS + EXECUTE_MAX_SIE
 
 // The initial budget at an entry point. This needs to be high enough to cover the initial get_gas.
 // The entry point may refund whatever remains from the initial budget.
-const ENTRY_POINT_INITIAL_BUDGET = 100 * STEP_GAS_COST;
+const ENTRY_POINT_INITIAL_BUDGET = 10000;
 // The gas cost of each syscall libfunc (this value is hard-coded by the compiler).
 // This needs to be high enough to cover OS costs in the case of failure due to out of gas.
-const SYSCALL_BASE_GAS_COST = 100 * STEP_GAS_COST;
+const SYSCALL_BASE_GAS_COST = 10000;
 
 // Syscall gas costs.
-const CALL_CONTRACT_GAS_COST = 18 * RANGE_CHECK_GAS_COST + 903 * STEP_GAS_COST;
-const DEPLOY_GAS_COST = 7 * PEDERSEN_GAS_COST + 21 * RANGE_CHECK_GAS_COST + 1173 * STEP_GAS_COST;
-const DEPLOY_CALLDATA_FACTOR_GAS_COST = 1 * PEDERSEN_GAS_COST + 8 * STEP_GAS_COST;
-const GET_BLOCK_HASH_GAS_COST = 2 * RANGE_CHECK_GAS_COST + 107 * STEP_GAS_COST;
-const GET_CLASS_HASH_AT_GAS_COST = 1 * SYSCALL_BASE_GAS_COST;
-const GET_EXECUTION_INFO_GAS_COST = 2 * RANGE_CHECK_GAS_COST + 125 * STEP_GAS_COST;
-const LIBRARY_CALL_GAS_COST = 18 * RANGE_CHECK_GAS_COST + 879 * STEP_GAS_COST;
-const REPLACE_CLASS_GAS_COST = 1 * RANGE_CHECK_GAS_COST + 106 * STEP_GAS_COST;
-const STORAGE_READ_GAS_COST = 1 * SYSCALL_BASE_GAS_COST;
-const STORAGE_WRITE_GAS_COST = 1 * SYSCALL_BASE_GAS_COST;
-const EMIT_EVENT_GAS_COST = 1 * SYSCALL_BASE_GAS_COST;
-const SEND_MESSAGE_TO_L1_GAS_COST = 1 * RANGE_CHECK_GAS_COST + 144 * STEP_GAS_COST;
-const META_TX_V0_GAS_COST = 9 * PEDERSEN_GAS_COST + 20 * RANGE_CHECK_GAS_COST + 1301 *
-    STEP_GAS_COST;
-const META_TX_V0_CALLDATA_FACTOR_GAS_COST = 1 * PEDERSEN_GAS_COST + 8 * STEP_GAS_COST;
+const CALL_CONTRACT_GAS_COST = 91560;
+const DEPLOY_GAS_COST = 147120;
+const DEPLOY_CALLDATA_FACTOR_GAS_COST = 4850;
+const GET_BLOCK_HASH_GAS_COST = 10840;
+const GET_CLASS_HASH_AT_GAS_COST = 10000;
+const GET_EXECUTION_INFO_GAS_COST = 12640;
+const LIBRARY_CALL_GAS_COST = 89160;
+const REPLACE_CLASS_GAS_COST = 10670;
+const STORAGE_READ_GAS_COST = 10000;
+const STORAGE_WRITE_GAS_COST = 10000;
+const EMIT_EVENT_GAS_COST = 10000;
+const SEND_MESSAGE_TO_L1_GAS_COST = 14470;
+const META_TX_V0_GAS_COST = 167950;
+const META_TX_V0_CALLDATA_FACTOR_GAS_COST = 4850;
 
 // Note the the following costs include `SYSCALL_BASE_GAS_COST` implicitly.
-const SECP256K1_ADD_GAS_COST = 29 * RANGE_CHECK_GAS_COST + 412 * STEP_GAS_COST;
-const SECP256K1_GET_POINT_FROM_X_GAS_COST = 30 * RANGE_CHECK_GAS_COST + 397 * STEP_GAS_COST;
-const SECP256K1_GET_XY_GAS_COST = 11 * RANGE_CHECK_GAS_COST + 209 * STEP_GAS_COST;
-const SECP256K1_MUL_GAS_COST = 7045 * RANGE_CHECK_GAS_COST + 76507 * STEP_GAS_COST;
-const SECP256K1_NEW_GAS_COST = 35 * RANGE_CHECK_GAS_COST + 463 * STEP_GAS_COST;
-const SECP256R1_ADD_GAS_COST = 57 * RANGE_CHECK_GAS_COST + 595 * STEP_GAS_COST;
-const SECP256R1_GET_POINT_FROM_X_GAS_COST = 44 * RANGE_CHECK_GAS_COST + 516 * STEP_GAS_COST;
-const SECP256R1_GET_XY_GAS_COST = 11 * RANGE_CHECK_GAS_COST + 211 * STEP_GAS_COST;
-const SECP256R1_MUL_GAS_COST = 13961 * RANGE_CHECK_GAS_COST + 125346 * STEP_GAS_COST;
-const SECP256R1_NEW_GAS_COST = 49 * RANGE_CHECK_GAS_COST + 582 * STEP_GAS_COST;
-
-const KECCAK_GAS_COST = 1 * SYSCALL_BASE_GAS_COST;
-const KECCAK_ROUND_COST_GAS_COST = 6 * BITWISE_BUILTIN_GAS_COST + 1 * KECCAK_BUILTIN_GAS_COST + 56 *
-    RANGE_CHECK_GAS_COST + 281 * STEP_GAS_COST;
-const SHA256_PROCESS_BLOCK_GAS_COST = 1115 * BITWISE_BUILTIN_GAS_COST + 65 * RANGE_CHECK_GAS_COST +
-    1867 * STEP_GAS_COST;
+const SECP256K1_ADD_GAS_COST = 43230;
+const SECP256K1_GET_POINT_FROM_X_GAS_COST = 41800;
+const SECP256K1_GET_XY_GAS_COST = 21670;
+const SECP256K1_MUL_GAS_COST = 8143850;
+const SECP256K1_NEW_GAS_COST = 48750;
+const SECP256R1_ADD_GAS_COST = 63490;
+const SECP256R1_GET_POINT_FROM_X_GAS_COST = 54680;
+const SECP256R1_GET_XY_GAS_COST = 21870;
+const SECP256R1_MUL_GAS_COST = 13511870;
+const SECP256R1_NEW_GAS_COST = 61630;
+
+const KECCAK_GAS_COST = 10000;
+const KECCAK_ROUND_COST_GAS_COST = 171707;
+const SHA256_PROCESS_BLOCK_GAS_COST = 841295;
 
 // Cairo 1.0 error codes.
 const ERROR_BLOCK_NUMBER_OUT_OF_RANGE = 'Block number out of range';
@@ -167,7 +164,10 @@ const V1_BOUND_ACCOUNTS_CAIRO0_3 = (
 const V1_BOUND_ACCOUNTS_CAIRO0_4 = (
     0x041cb0280ebadaa75f996d8d92c6f265f6d040bb3ba442e5f86a554f1765244e
 );
-const V1_BOUND_ACCOUNTS_CAIRO0_LEN = 5;
+const V1_BOUND_ACCOUNTS_CAIRO0_5 = (
+    0x03530cc4759d78042f1b543bf797f5f3d647cde0388c33734cf91b7f7b9314a9
+);
+const V1_BOUND_ACCOUNTS_CAIRO0_LEN = 6;
 
 // List of Cairo1 account contracts that require the transaction version to be 1.
 const V1_BOUND_ACCOUNTS_CAIRO1_0 = (
@@ -200,5 +200,5 @@ const V1_BOUND_ACCOUNTS_MAX_TIP = 0x746a5288000;
 const DATA_GAS_ACCOUNTS_0 = 0x02c8c7e6fbcfb3e8e15a46648e8914c6aa1fc506fc1e7fb3d1e19630716174bc;
 const DATA_GAS_ACCOUNTS_1 = 0x00816dd0297efc55dc1e7559020a3a825e81ef734b558f03c83325d4da7e6253;
 const DATA_GAS_ACCOUNTS_2 = 0x041bf1e71792aecb9df3e9d04e1540091c5e13122a731e02bec588f71dc1a5c3;
-const DATA_GAS_ACCOUNTS_3 = 0x6d612cac7690e6620055c617a83a5a0b43b9758d9d30f281ddbc77be1651a70;
+const DATA_GAS_ACCOUNTS_3 = 0x06d612cac7690e6620055c617a83a5a0b43b9758d9d30f281ddbc77be1651a70;
 const DATA_GAS_ACCOUNTS_LEN = 4;

cairo-lang-0.14.0.1/starkware/starknet/core/os/contract_class/class_hash.py

@@ -0,0 +1,18 @@
+from starkware.starknet.core.os.contract_class.class_hash_utils import py_compute_class_hash
+from starkware.starknet.core.os.contract_class.utils import ClassHashType, class_hash_cache_ctx_var
+from starkware.starknet.public.abi import starknet_keccak
+from starkware.starknet.services.api.contract_class.contract_class import ContractClass
+
+
+def compute_class_hash(contract_class: ContractClass) -> int:
+    cache = class_hash_cache_ctx_var.get()
+    if cache is None:
+        return py_compute_class_hash(contract_class)
+
+    contract_class_bytes = contract_class.dumps(sort_keys=True).encode()
+    key = (ClassHashType.CONTRACT_CLASS, starknet_keccak(data=contract_class_bytes))
+
+    if key not in cache:
+        cache[key] = py_compute_class_hash(contract_class)
+
+    return cache[key]