cairo-lang 0.14.0__zip → 0.14.0.1__zip

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.14.0
+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.0 → 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.0
+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.0 → cairo-lang-0.14.0.1}/cairo_lang.egg-info/SOURCES.txt

@@ -42,6 +42,10 @@ starkware/cairo/bootloaders/fact_topology.py
 starkware/cairo/bootloaders/generate_fact.py
 starkware/cairo/bootloaders/hash_program.py
 starkware/cairo/bootloaders/program_hash_test_utils.py
+starkware/cairo/builtin_selection/inner_select_builtins.cairo
+starkware/cairo/builtin_selection/select_builtins.cairo
+starkware/cairo/builtin_selection/select_input_builtins.cairo
+starkware/cairo/builtin_selection/validate_builtins.cairo
 starkware/cairo/common/__init__.py
 starkware/cairo/common/alloc.cairo
 starkware/cairo/common/bitwise.cairo
@@ -318,6 +322,7 @@ starkware/python/utils_stub_module.py
 starkware/starknet/__init__.py
 starkware/starknet/builtins/__init__.py
 starkware/starknet/builtins/segment_arena/__init__.py
+starkware/starknet/builtins/segment_arena/segment_arena.cairo
 starkware/starknet/builtins/segment_arena/segment_arena_builtin_runner.py
 starkware/starknet/business_logic/__init__.py
 starkware/starknet/business_logic/utils.py

cairo-lang-0.14.0.1/starkware/cairo/builtin_selection/inner_select_builtins.cairo

@@ -0,0 +1,71 @@
+// An helper function to extract selected_ptrs from all_ptrs according to the builtin encodings
+// that appear in the selected_encodings list.
+// The caller needs to pass n_selected_builtins as a hint.
+// Returns a pointer to the next memory slot after the selected_encodings list, see "Assumptions".
+//
+// For example, given the following setup:
+//   - all_encodings points to ["output", "pedersen", "range-check"].
+//   - selected_encodings points to ["output", "range-check"]
+//   - all_ptrs points to [output_ptr, pedersen_ptr, range_check_ptr]
+//   - The caller asserts that the return value is selected_encodings + n_selected_builtins(2).
+// The function will check that selected_encodings points to [output_ptr, range_check_ptr].
+//
+// n_builtins is the length of the list of *all pointers*.
+// Assumptions:
+// * The caller has to check that n_selected_builtins = selected_encodings_end - selected_encodings.
+// * All lists are sorted according to the order of builtins input in Cairo programs.
+// * len(selected_encodings) <= len(all_encodings) == len(all_ptrs).
+func inner_select_builtins(
+    all_encodings: felt*,
+    all_ptrs: felt*,
+    selected_encodings: felt*,
+    selected_ptrs: felt*,
+    n_builtins,
+) -> (selected_encodings_end: felt*) {
+    // Number of memory cells used when n_builtins = 0.
+    const FUNC_MEMORY_NO_BUILTINS = 1;
+    // Number of memory cells used *in a single iteration* when n_builtins > 0.
+    const FUNC_MEMORY_WITH_BUILTINS = 10;
+
+    if (n_builtins == 0) {
+        // Return a pointer to the end of the selected_encodings list.
+        return (selected_encodings_end=selected_encodings);
+    }
+
+    alloc_locals;
+    // select_builtin equals 1 if the first builtin should be selected and 0 otherwise.
+    local select_builtin;
+    %{
+        # A builtin should be selected iff its encoding appears in the selected encodings list
+        # and the list wasn't exhausted.
+        # Note that testing inclusion by a single comparison is possible since the lists are sorted.
+        ids.select_builtin = int(
+          n_selected_builtins > 0 and memory[ids.selected_encodings] == memory[ids.all_encodings])
+        if ids.select_builtin:
+          n_selected_builtins = n_selected_builtins - 1
+    %}
+    // Verify that select_builtin is a bit.
+    select_builtin = select_builtin * select_builtin;
+
+    local curr_builtin_encoding = [all_encodings];
+    local curr_builtin_ptr = [all_ptrs];
+
+    if (select_builtin != 0) {
+        // Verify that the current builtin is indeed selected, by asserting that its encoding
+        // appears in the selected encodings list.
+        curr_builtin_encoding = [selected_encodings];
+        // Copy the current builtin pointer between selected_ptrs and all_ptrs.
+        curr_builtin_ptr = [selected_ptrs];
+    }
+
+    // Advance all list pointers accordingly and continue selection by calling inner_select_builtins
+    // recursively.
+    // Lists of selected builtins/encodings should advance only if the current builtin was selected.
+    return inner_select_builtins(
+        all_encodings=all_encodings + 1,
+        all_ptrs=all_ptrs + 1,
+        selected_encodings=selected_encodings + select_builtin,
+        selected_ptrs=selected_ptrs + select_builtin,
+        n_builtins=n_builtins - 1,
+    );
+}

cairo-lang-0.14.0.1/starkware/cairo/builtin_selection/select_builtins.cairo

@@ -0,0 +1,25 @@
+from starkware.cairo.builtin_selection.inner_select_builtins import inner_select_builtins
+
+// A wrapper for 'inner_select_builtins' function (see its documentation).
+func select_builtins(
+    n_builtins,
+    all_encodings: felt*,
+    all_ptrs: felt*,
+    n_selected_builtins,
+    selected_encodings: felt*,
+    selected_ptrs: felt*,
+) {
+    %{ vm_enter_scope({'n_selected_builtins': ids.n_selected_builtins}) %}
+    let (selected_encodings_end) = inner_select_builtins(
+        all_encodings=all_encodings,
+        all_ptrs=all_ptrs,
+        selected_encodings=selected_encodings,
+        selected_ptrs=selected_ptrs,
+        n_builtins=n_builtins,
+    );
+    %{ vm_exit_scope() %}
+    // Assert that the correct number of builtins was selected.
+    assert n_selected_builtins = selected_encodings_end - selected_encodings;
+
+    return ();
+}

cairo-lang-0.14.0.1/starkware/cairo/builtin_selection/select_input_builtins.cairo

@@ -0,0 +1,40 @@
+from starkware.cairo.builtin_selection.inner_select_builtins import inner_select_builtins
+from starkware.cairo.common.registers import get_fp_and_pc
+
+// A wrapper for 'inner_select_builtins' function (see its documentation).
+// Returns the selected builtin pointers (e.g., if n_selected_builtins=2, returns two values).
+func select_input_builtins(
+    all_encodings: felt*,
+    all_ptrs: felt*,
+    n_all_builtins: felt,
+    selected_encodings: felt*,
+    n_selected_builtins,
+) {
+    // Number of memory cells used, without taking the inner function memory into account.
+    const FUNC_MEMORY_WITHOUT_INNER_FUNC = 11;
+    const INNER_FUNC_MEMORY_PER_ITERATION = inner_select_builtins.FUNC_MEMORY_WITH_BUILTINS;
+    const INNER_FUNC_MEMORY_FINAL_ITERATION = inner_select_builtins.FUNC_MEMORY_NO_BUILTINS;
+    // 'inner_select_builtins' has n_all_builtins iterations, until the final halting one, when
+    // called with n_builtins = n_all_builtins.
+    let inner_func_memory = n_all_builtins * INNER_FUNC_MEMORY_PER_ITERATION +
+        INNER_FUNC_MEMORY_FINAL_ITERATION;
+    let total_func_memory = inner_func_memory + FUNC_MEMORY_WITHOUT_INNER_FUNC;
+
+    let frame = call get_fp_and_pc;
+    // The selected builtin pointers are the return values at the end of the function memory.
+    let selected_ptrs = frame.fp_val + total_func_memory;
+    %{ vm_enter_scope({'n_selected_builtins': ids.n_selected_builtins}) %}
+    let inner_ret = inner_select_builtins(
+        all_encodings=all_encodings,
+        all_ptrs=all_ptrs,
+        selected_encodings=selected_encodings,
+        selected_ptrs=selected_ptrs,
+        n_builtins=n_all_builtins,
+    );
+    %{ vm_exit_scope() %}
+    // Assert that the correct number of builtins was selected.
+    n_selected_builtins = inner_ret.selected_encodings_end - selected_encodings;
+
+    ap += n_selected_builtins;
+    ret;
+}

cairo-lang-0.14.0.1/starkware/cairo/builtin_selection/validate_builtins.cairo

@@ -0,0 +1,56 @@
+// Validates that the builtin pointer of a single builtin was advanced correctly.
+// The inputs are:
+//   The previous builtin pointer.
+//   The new builtin pointer.
+//   The size of the builtin instances.
+// The function validates that the difference between the new builtin pointer and the old builtin
+// pointer is a positive integer divisible by the given builtin instance size.
+//
+// The function consumes 1 range check instance starting at range_check_ptr and returns the
+// updated range check pointer.
+func validate_builtin{range_check_ptr}(
+    prev_builtin_ptr: felt*, new_builtin_ptr: felt*, builtin_instance_size: felt
+) {
+    // Check that the difference is positive and divisible by builtin_instance_size by checking that
+    // 0 <= div_res < RANGE_CHECK_BOUND and diff = div_res * builtin_instance_size.
+    tempvar diff = new_builtin_ptr - prev_builtin_ptr;
+    tempvar div_res = diff / builtin_instance_size;
+    div_res = [range_check_ptr];
+    let range_check_ptr = range_check_ptr + 1;
+    return ();
+}
+
+// Validates that the builtin pointers were advanced correctly.
+//
+// The inputs are:
+//   The previous list of builtin pointers.
+//   The new list of builtin pointers.
+//   The sizes of the builtin instances.
+//   The number of builtins.
+//
+// For each builtin the function validates that the difference between the new builtin pointer and
+// the old builtin pointer is a nonnegative integer divisible by the corresponding builtin
+// instance size.
+//
+// The function consumes n_builtins range check instances starting at range_check_ptr and returns
+// the updated range check pointer.
+func validate_builtins{range_check_ptr}(
+    prev_builtin_ptrs: felt*, new_builtin_ptrs: felt*, builtin_instance_sizes: felt*, n_builtins
+) {
+    if (n_builtins == 0) {
+        return ();
+    }
+
+    validate_builtin(
+        prev_builtin_ptr=cast([prev_builtin_ptrs], felt*),
+        new_builtin_ptr=cast([new_builtin_ptrs], felt*),
+        builtin_instance_size=[builtin_instance_sizes],
+    );
+
+    return validate_builtins(
+        prev_builtin_ptrs=prev_builtin_ptrs + 1,
+        new_builtin_ptrs=new_builtin_ptrs + 1,
+        builtin_instance_sizes=builtin_instance_sizes + 1,
+        n_builtins=n_builtins - 1,
+    );
+}

{cairo-lang-0.14.0 → 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;

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

@@ -166,7 +166,7 @@ def calculate_blake2s_hash_from_felt252s(
     total_bytes = len(words) * 4
     bytes_seen = 0
 
-    for i in range(0, len(words), 16):
+    for i in range(0, max(len(words), 1), 16):
         block = words[i : i + 16]
         if len(block) < 16:
             block += [0] * (16 - len(block))

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

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

{cairo-lang-0.14.0 → 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.0.1/starkware/starknet/builtins/segment_arena/segment_arena.cairo

@@ -0,0 +1,94 @@
+from starkware.cairo.common.alloc import alloc
+
+// The segment arena builtin allows Sierra libfuncs to allocate memory segments and only track their
+// ends (rather than both the start and the end). When the segment is finalized, the arena can
+// provide the start pointer that corresponds to the segment (given its end).
+//
+// The builtin should be used as follows:
+// * Every segment must be allocated and finalized exactly once. This can be achieved by using
+//   linear types (the object holding the segment must not be duplicatable nor droppable).
+// * Segment allocation:
+//   * Allocates a new segment and updates `SegmentInfo::start` with the pointer.
+//   * The segment should be temporary if `n_segments > 0`.
+//   * Increases `n_segments` by 1.
+// * Segment finalization:
+//   * Guesses the index of the segment, in the range [0, n_segments).
+//   * Writes the end of the segment in `SegmentInfo::end`.
+//   * Copies the current value of `n_finalized` to `SegmentInfo::finalization_index`.
+//   * Increases `n_finalized` by 1.
+//   * Checks that the segment size is nonnegative (range-check on `end - start`).
+
+// Represents the information about a single segment allocated by the arena.
+struct SegmentInfo {
+    // A pointer to the first element of this segment.
+    start: felt*,
+    // A pointer to the end of this segment (the first unused element).
+    end: felt*,
+    // A sequential id, assigned to the segment when it is finalized.
+    // This value is used to guarantee that 'end' is not assigned twice.
+    finalization_index: felt,
+}
+
+// Represents the status of the segment arena.
+struct SegmentArenaBuiltin {
+    // A pointer to a list of SegmentInfo. infos[i] contains information about the i-th segment
+    // (ordered by construction).
+    // The value is fixed during the execution of an entry point.
+    infos: SegmentInfo*,
+    // The number of segments that were created so far.
+    n_segments: felt,
+    // The number of segments that were finalized so far.
+    n_finalized: felt,
+}
+
+// Constructs a new segment for the segment arena builtin and initializes it with an empty instance
+// of `SegmentArenaBuiltin`.
+func new_arena() -> SegmentArenaBuiltin* {
+    let (segment_arena: SegmentArenaBuiltin*) = alloc();
+    assert segment_arena[0] = SegmentArenaBuiltin(
+        infos=cast(nondet %{ segments.add() %}, SegmentInfo*), n_segments=0, n_finalized=0
+    );
+    return &segment_arena[1];
+}
+
+// Validates the segment arena builtin.
+//
+// In particular, relocates the temporary segments such that the start of segment i is strictly
+// larger than the end of segment i+1.
+func validate_segment_arena(segment_arena: SegmentArenaBuiltin*) {
+    tempvar n_segments = segment_arena.n_segments;
+    tempvar n_finalized = segment_arena.n_finalized;
+    // The following line should follow from the fact that every allocated segment
+    // must be finalized exactly once.
+    // We keep it both as a sanity check and since Sierra compilation is not proven yet.
+    assert n_segments = n_finalized;
+
+    if (n_segments == 0) {
+        return ();
+    }
+
+    // The following call also implies that n_segments > 0.
+    _verify_continuity(infos=segment_arena.infos, n_segments_minus_one=n_segments - 1);
+    return ();
+}
+
+// Helper function for validate_segment_arena.
+func _verify_continuity(infos: SegmentInfo*, n_segments_minus_one: felt) {
+    if (n_segments_minus_one == 0) {
+        // If there is only one segment left, there is no need to check anything.
+        return ();
+    }
+
+    // Enforce an empty cell between two consecutive segments so that the start of a segment
+    // is strictly bigger than the end of the previous segment.
+    // This is required for proving the soundness of this construction, in the case where a segment
+    // has length zero.
+
+    // Note: the following code was copied from relocate_segment() for efficiency reasons.
+    let src_ptr = infos[1].start;
+    let dest_ptr = infos[0].end + 1;
+    %{ memory.add_relocation_rule(src_ptr=ids.src_ptr, dest_ptr=ids.dest_ptr) %}
+    assert src_ptr = dest_ptr;
+
+    return _verify_continuity(infos=&infos[1], n_segments_minus_one=n_segments_minus_one - 1);
+}

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

@@ -164,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 = (

{cairo-lang-0.14.0 → cairo-lang-0.14.0.1}/starkware/starknet/core/os/os_utils.py

@@ -35,7 +35,8 @@ from starkware.starkware_utils.marshmallow_dataclass_fields import IntAsHex, add
 from starkware.starkware_utils.validated_dataclass import ValidatedMarshmallowDataclass
 from starkware.storage.storage import Storage
 
-OS_PROGRAM_HASH_RELATIVE_PATH = "src/starkware/starknet/core/os/program_hash.json"
+STARKNET_CORE_PATH_FROM_SRC = "starkware/starknet/core"
+OS_PROGRAM_HASH_RELATIVE_PATH = f"src/{STARKNET_CORE_PATH_FROM_SRC}/os/program_hash.json"
 OS_PROGRAM_HASH_PATH = get_source_dir_path(
     OS_PROGRAM_HASH_RELATIVE_PATH,
     default_value=os.path.join(os.path.dirname(__file__), "program_hash.json"),

{cairo-lang-0.14.0 → cairo-lang-0.14.0.1}/starkware/starknet/core/os/starknet_builtins.json

@@ -1,7 +1,7 @@
 {
     "attributes": [],
     "builtins": [],
-    "compiler_version": "0.14.0",
+    "compiler_version": "0.14.0.1",
     "data": [
         "0x208b7fff7fff7ffe",
         "0x20780017fff7ffd",