feat(apollo_starknet_os_program): copy OS cairo code

Author: dorimedini-starkware

crates/apollo_starknet_os_program/src/cairo/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,
+    );
+}

crates/apollo_starknet_os_program/src/cairo/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 ();
+}

crates/apollo_starknet_os_program/src/cairo/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;
+}

crates/apollo_starknet_os_program/src/cairo/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,
+    );
+}

crates/apollo_starknet_os_program/src/cairo/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);
+}

crates/apollo_starknet_os_program/src/cairo/starkware/starknet/common/constants.cairo

@@ -0,0 +1,9 @@
+// The dummy caller address of an externally originated transaction.
+const ORIGIN_ADDRESS = 0;
+
+// Transaction hash prefixes.
+const DECLARE_HASH_PREFIX = 'declare';
+const DEPLOY_HASH_PREFIX = 'deploy';
+const DEPLOY_ACCOUNT_HASH_PREFIX = 'deploy_account';
+const INVOKE_HASH_PREFIX = 'invoke';
+const L1_HANDLER_HASH_PREFIX = 'l1_handler';

crates/apollo_starknet_os_program/src/cairo/starkware/starknet/common/eth_utils.cairo

@@ -0,0 +1,14 @@
+from starkware.cairo.common.math import assert_lt_felt, assert_not_zero
+
+const ETH_ADDRESS_BOUND = 2 ** 160;
+
+func assert_eth_address_range{range_check_ptr}(address: felt) {
+    with_attr error_message("Invalid Ethereum address - value is more than 160 bits") {
+        assert_lt_felt(address, ETH_ADDRESS_BOUND);
+    }
+
+    with_attr error_message("Invalid Ethereum address - value is zero") {
+        assert_not_zero(address);
+    }
+    return ();
+}

crates/apollo_starknet_os_program/src/cairo/starkware/starknet/common/messages.cairo

@@ -0,0 +1,14 @@
+from starkware.starknet.common.syscalls import SEND_MESSAGE_TO_L1_SELECTOR, SendMessageToL1SysCall
+
+// Sends a message to an L1 contract at 'l1_address' with given payload.
+func send_message_to_l1{syscall_ptr: felt*}(to_address: felt, payload_size: felt, payload: felt*) {
+    assert [cast(syscall_ptr, SendMessageToL1SysCall*)] = SendMessageToL1SysCall(
+        selector=SEND_MESSAGE_TO_L1_SELECTOR,
+        to_address=to_address,
+        payload_size=payload_size,
+        payload_ptr=payload,
+    );
+    %{ syscall_handler.send_message_to_l1(segments=segments, syscall_ptr=ids.syscall_ptr) %}
+    let syscall_ptr = syscall_ptr + SendMessageToL1SysCall.SIZE;
+    return ();
+}