Evaluator.cairo

# ######## ERC 721 evaluator
# Soundtrack https://www.youtube.com/watch?v=iuWa5wh8lG0

%lang starknet

from starkware.cairo.common.cairo_builtins import HashBuiltin, BitwiseBuiltin
from starkware.cairo.common.math import assert_not_zero

from contracts.utils.ex00_base import (
    tderc20_address,
    distribute_points,
    ex_initializer,
    has_validated_exercise,
    validate_exercice,
)

from contracts.token.ERC721.IERC721 import IERC721
from contracts.token.ERC721.IERC721_metadata import IERC721_metadata
from contracts.IExerciceSolution import IExerciceSolution
from starkware.starknet.common.syscalls import get_contract_address, get_caller_address
from starkware.cairo.common.uint256 import (
    Uint256,
    uint256_add,
    uint256_sub,
    uint256_le,
    uint256_lt,
    uint256_check,
    uint256_eq,
)
from contracts.token.ERC20.ITDERC20 import ITDERC20
from contracts.token.ERC20.IERC20 import IERC20

#
# Declaring storage vars
# Storage vars are by default not visible through the ABI. They are similar to "private" variables in Solidity
#

@storage_var
func has_been_paired(contract_address : felt) -> (has_been_paired : felt):
end

@storage_var
func player_exercise_solution_storage(player_address : felt) -> (contract_address : felt):
end

@storage_var
func assigned_rank_storage(player_address : felt) -> (rank : felt):
end

@storage_var
func next_rank_storage() -> (next_rank : felt):
end

@storage_var
func max_rank_storage() -> (max_rank : felt):
end

@storage_var
func random_attributes_storage(column : felt, rank : felt) -> (value : felt):
end

@storage_var
func was_initialized() -> (was_initialized : felt):
end

@storage_var
func dummy_token_address_storage() -> (dummy_token_address_storage : felt):
end

@storage_var
func dummy_metadata_erc721_storage() -> (dummy_metadata_erc721_storage : felt):
end

#
# Declaring getters
# Public variables should be declared explicitly with a getter
#

@view
func player_exercise_solution{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    player_address : felt
) -> (contract_address : felt):
    let (contract_address) = player_exercise_solution_storage.read(player_address)
    return (contract_address)
end

@view
func assigned_rank{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    player_address : felt
) -> (rank : felt):
    let (rank) = assigned_rank_storage.read(player_address)
    return (rank)
end

@view
func assigned_legs_number{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    player_address : felt
) -> (legs : felt):
    let (rank) = assigned_rank(player_address)
    let (legs) = random_attributes_storage.read(0, rank)
    return (legs)
end

@view
func assigned_sex_number{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    player_address : felt
) -> (sex : felt):
    let (rank) = assigned_rank(player_address)
    let (sex) = random_attributes_storage.read(1, rank)
    return (sex)
end

@view
func assigned_wings_number{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    player_address : felt
) -> (wings : felt):
    let (rank) = assigned_rank(player_address)
    let (wings) = random_attributes_storage.read(2, rank)
    return (wings)
end

# ######## Constructor
# This function is called when the contract is deployed
#
@constructor
func constructor{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    _tderc20_address : felt,
    _players_registry : felt,
    _workshop_id : felt,
    dummy_metadata_erc721_address : felt,
    _dummy_token_address : felt,
):
    ex_initializer(_tderc20_address, _players_registry, _workshop_id)
    dummy_token_address_storage.write(_dummy_token_address)
    dummy_metadata_erc721_storage.write(dummy_metadata_erc721_address)
    # Hard coded value for now
    max_rank_storage.write(100)
    return ()
end

# ######## External functions
# These functions are callable by other contracts
#

@external
func ex1_test_erc721{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}():
    # Allocating locals. Make your code easier to write and read by avoiding some revoked references
    alloc_locals
    # Reading caller address
    let (sender_address) = get_caller_address()
    let token_id : Uint256 = Uint256(1, 0)
    # Retrieve exercise address
    let (submited_exercise_address) = player_exercise_solution_storage.read(sender_address)

    # Reading evaluator address
    let (evaluator_address) = get_contract_address()
    # Reading who owns token 1 of exercise
    let (token_1_owner_init) = IERC721.ownerOf(
        contract_address=submited_exercise_address, token_id=token_id
    )

    with_attr error_message("Token 1 doesn't belong to the evaluator"):
        # Verifying that token 1 belongs to evaluator
        assert evaluator_address = token_1_owner_init
    end
    # Reading balance of evaluator in exercise
    let (evaluator_init_balance) = IERC721.balanceOf(
        contract_address=submited_exercise_address, owner=evaluator_address
    )
    # Reading balance of msg sender in exercise
    let (sender_init_balance) = IERC721.balanceOf(
        contract_address=submited_exercise_address, owner=sender_address
    )

    # Instanciating a zero in uint format
    let zero_as_uint256 : Uint256 = Uint256(0, 0)
    let (is_equal) = uint256_eq(evaluator_init_balance, zero_as_uint256)
    with_attr error_message("Evaluator's balance is 0"):
        assert is_equal = 0
    end

    # Check that token 1 can be transferred back to msg.sender
    with_attr error_message("Can't transfer the token 1"):
        IERC721.transferFrom(
            contract_address=submited_exercise_address,
            _from=evaluator_address,
            to=sender_address,
            token_id=token_id,
        )
    end

    # Reading balance of msg sender after transfer
    let (sender_end_balance) = IERC721.balanceOf(
        contract_address=submited_exercise_address, owner=sender_address
    )
    # Reading balance of evaluator after transfer
    let (evaluator_end_balance) = IERC721.balanceOf(
        contract_address=submited_exercise_address, owner=evaluator_address
    )
    # Reading who owns token 1 of exercise
    let (token_1_owner_end) = IERC721.ownerOf(
        contract_address=submited_exercise_address, token_id=token_id
    )
    # Verifying that token 1 belongs to sender
    with_attr error_message("Token 1 doesn't belong to the sender"):
        assert token_1_owner_end = sender_address
    end
    # I need value 1 in the uint format to be able to substract it, and add it, to compare balances
    let one_as_uint256 : Uint256 = Uint256(1, 0)
    # Store expected balance in a variable, since I can't use everything on a single line
    let evaluator_expected_balance : Uint256 = uint256_sub(evaluator_init_balance, one_as_uint256)
    let (sender_expected_balance, _) = uint256_add(sender_init_balance, one_as_uint256)
    # Verifying that balances where updated correctly
    let (is_sender_balance_equal_to_expected) = uint256_eq(
        sender_expected_balance, sender_end_balance
    )
    with_attr error_message("Sender's balance wasn't updated"):
        assert is_sender_balance_equal_to_expected = 1
    end

    let (is_evaluator_balance_equal_to_expected) = uint256_eq(
        evaluator_expected_balance, evaluator_end_balance
    )
    with_attr error_message("Evaluator's balance wasn't updated"):
        assert is_evaluator_balance_equal_to_expected = 1
    end

    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 1)
    # This is necessary because of revoked references. Don't be scared, they won't stay around for too long...

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 1)
        # Sending points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

# Call this function to get assigned a rank, and the associate characteristics expected from your animal
@external
func ex2a_get_animal_rank{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}():
    alloc_locals

    # Reading caller address
    let (sender_address) = get_caller_address()

    ex2a_get_animal_rank_internal(sender_address)

    return ()
end

# Show that you properly declared your animal
@external
func ex2b_test_declare_animal{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    token_id : Uint256
):
    alloc_locals
    # Reading caller address
    let (sender_address) = get_caller_address()

    ex2b_test_declare_animal_internal(sender_address, token_id)

    return ()
end

# Create a function that allows any breeder to call your contract and declare a new animal
@external
func ex3_declare_new_animal{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}():
    alloc_locals
    # Reading caller address
    let (sender_address) = get_caller_address()
    # Retrieve exercise address
    let (submited_exercise_address) = player_exercise_solution_storage.read(sender_address)
    # Reading evaluator address
    let (evaluator_address) = get_contract_address()
    # Reading balance of evaluator in exercise
    let (evaluator_init_balance) = IERC721.balanceOf(
        contract_address=submited_exercise_address, owner=evaluator_address
    )
    # Requesting new attributes
    ex2a_get_animal_rank_internal(sender_address)

    # Retrieve expected characteristics
    let (expected_sex) = assigned_sex_number(sender_address)
    let (expected_legs) = assigned_legs_number(sender_address)
    let (expected_wings) = assigned_wings_number(sender_address)

    with_attr error_message("Couldn't declare a new animal"):
        # Declaring a new animal with the desired parameters
        let (created_token) = IExerciceSolution.declare_animal(
            contract_address=submited_exercise_address,
            sex=expected_sex,
            legs=expected_legs,
            wings=expected_wings,
        )
    end

    # Checking that the animal was declared correctly. We basically reuse ex2 lol
    # If it wasn't done correctly, this should fail
    ex2b_test_declare_animal_internal(sender_address, created_token)

    # Ok so if I got until here then... nothing failed. I get points
    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 3)

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 3)
        # Sending points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

# Sometimes, animals die. Your contract should implement that.
@external
func ex4_declare_dead_animal{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}():
    alloc_locals
    # Reading caller address
    let (sender_address) = get_caller_address()
    # Retrieve exercise address
    let (submited_exercise_address) = player_exercise_solution_storage.read(sender_address)
    # Reading evaluator address
    let (evaluator_address) = get_contract_address()
    # Getting initial token balance. Must be at least 1
    let (evaluator_init_balance) = IERC721.balanceOf(
        contract_address=submited_exercise_address, owner=evaluator_address
    )

    # Getting an animal id of Evaluator. tokenOfOwnerByIndex should return the list of NFTs owned by and address
    with_attr error_message("Can't get the token owner by the index"):
        let (token_id) = IExerciceSolution.token_of_owner_by_index(
            contract_address=submited_exercise_address, account=evaluator_address, index=0
        )
    end

    with_attr error_message("Can't declare a dead animal"):
        # Declaring it as dead
        IExerciceSolution.declare_dead_animal(
            contract_address=submited_exercise_address, token_id=token_id
        )
    end

    # Checking end balance
    let (evaluator_end_balance) = IERC721.balanceOf(
        contract_address=submited_exercise_address, owner=evaluator_address
    )
    # I need value 1 in the uint format to be able to substract it, and add it, to compare balances
    let one_as_uint256 : Uint256 = Uint256(1, 0)
    # Store expected balance in a variable, since I can't use everything on a single line
    let evaluator_expected_balance : Uint256 = uint256_sub(evaluator_init_balance, one_as_uint256)
    # Verifying that balances where updated correctly
    let (is_evaluator_balance_equal_to_expected) = uint256_eq(
        evaluator_expected_balance, evaluator_end_balance
    )
    with_attr error_message(
            "The dead animal shouldn't count in the evaluator's balance (he should be burnt)"):
        assert is_evaluator_balance_equal_to_expected = 1
    end

    with_attr error_message("Couldn't get the animal's characteristics"):
        # Check that properties are deleted
        # Reading animal characteristic in player solution
        let (read_sex, read_legs, read_wings) = IExerciceSolution.get_animal_characteristics(
            contract_address=submited_exercise_address, token_id=token_id
        )
    end

    # Checking characteristics are correct
    with_attr error_message("Dead animal's sex should be 0"):
        assert read_sex = 0
    end

    with_attr error_message("Dead animal's legs should be 0"):
        assert read_legs = 0
    end

    with_attr error_message("Dead animal's wings should be 0"):
        assert read_wings = 0
    end
    # TODO Testing killing another person's animal. The caller has to hold an animal
    # Requires try / catch, or something smarter. I'll think about it.

    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 4)

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 4)
        # Sending points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

# For ex5 you need ERC20 tokens. Go get them
@external
func ex5a_i_have_dtk{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}():
    alloc_locals
    # Reading caller address
    let (sender_address) = get_caller_address()
    # Reading sender balance in dummy token
    let (dummy_token_address) = dummy_token_address_storage.read()
    let (dummy_token_init_balance) = IERC20.balanceOf(
        contract_address=dummy_token_address, account=sender_address
    )

    # Verifying it's not 0
    # Instanciating a zero in uint format
    let zero_as_uint256 : Uint256 = Uint256(0, 0)
    let (is_equal) = uint256_eq(dummy_token_init_balance, zero_as_uint256)
    with_attr error_message("Caller should own some DTK"):
        assert is_equal = 0
    end

    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 51)

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 51)
        # Sending points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

# Allow breeder to pay for registration as a breeder
@external
func ex5b_register_breeder{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}():
    alloc_locals
    # Reading caller address
    let (sender_address) = get_caller_address()
    # Retrieve exercise address
    let (submited_exercise_address) = player_exercise_solution_storage.read(sender_address)
    # Get evaluator address
    let (evaluator_address) = get_contract_address()
    # Is evaluator currently a breeder?
    let (is_evaluator_breeder_init) = IExerciceSolution.is_breeder(
        contract_address=submited_exercise_address, account=evaluator_address
    )
    with_attr error_message("Evaluator shouldn't be a breeder for now"):
        assert is_evaluator_breeder_init = 0
    end
    # TODO test that evaluator can not yet declare an animal (requires try/catch)

    # Reading registration price. Registration is payable in dummy token
    with_attr error_message("Couldn't read the registration price"):
        let (registration_price) = IExerciceSolution.registration_price(
            contract_address=submited_exercise_address
        )
    end

    # Reading evaluator balance in dummy token
    let (dummy_token_address) = dummy_token_address_storage.read()
    let (dummy_token_init_balance) = IERC20.balanceOf(
        contract_address=dummy_token_address, account=evaluator_address
    )
    # Approve the exercice for spending my dummy tokens
    IERC20.approve(
        contract_address=dummy_token_address,
        spender=submited_exercise_address,
        amount=registration_price,
    )

    # Require breeder permission.
    with_attr error_message("Couldn't register the Evaluator as a breeder"):
        IExerciceSolution.register_me_as_breeder(contract_address=submited_exercise_address)
    end

    with_attr error_message("Couldn't check that the evaluator is a breeder"):
        # Check that I am indeed a breeder
        let (is_evaluator_breeder_end) = IExerciceSolution.is_breeder(
            contract_address=submited_exercise_address, account=evaluator_address
        )
    end
    with_attr error_message("Evaluator is not a breeder"):
        assert is_evaluator_breeder_end = 1
    end

    # Check that my balance has been updated
    let (dummy_token_end_balance) = IERC20.balanceOf(
        contract_address=dummy_token_address, account=evaluator_address
    )
    # Store expected balance in a variable, since I can't use everything on a single line
    let evaluator_expected_balance : Uint256 = uint256_sub(
        dummy_token_init_balance, registration_price
    )
    # Verifying that balances where updated correctly
    let (is_evaluator_balance_equal_to_expected) = uint256_eq(
        evaluator_expected_balance, dummy_token_end_balance
    )
    with_attr error_message(
            "Actual registration cost is not the one returned by registration_price"):
        assert is_evaluator_balance_equal_to_expected = 1
    end

    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 52)

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 52)
        # Sending points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

@external
func ex6_claim_metadata_token{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    token_id : Uint256
):
    # Allocating locals. Make your code easier to write and read by avoiding some revoked references
    alloc_locals
    # Retrieve dummy token address
    let (dummy_metadata_erc721_address) = dummy_metadata_erc721_storage.read()
    # Reading caller address
    let (sender_address) = get_caller_address()
    # Reading who owns token token_id
    let (token_owner) = IERC721.ownerOf(
        contract_address=dummy_metadata_erc721_address, token_id=token_id
    )
    # Verifying that token 1 belongs to evaluator
    with_attr error_message("Token 1 doesn't belong to the evaluator"):
        assert sender_address = token_owner
    end

    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 6)

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 6)
        # Sending points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

# Check that ERC721 has implemented metadata queries
@external
func ex7_add_metadata{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}():
    alloc_locals
    # Reading caller address
    let (sender_address) = get_caller_address()
    # Retrieve exercise address
    let (submited_exercise_address) = player_exercise_solution_storage.read(sender_address)
    # Get evaluator address
    let (evaluator_address) = get_contract_address()
    # Retrieve dummy token address
    let (dummy_metadata_erc721_address) = dummy_metadata_erc721_storage.read()
    # Reading metadata URI for token 1 on both contracts. For these to show up in Oasis, they should be equal
    let token_id = Uint256(1, 0)
    with_attr error_message("Couldn't retrieve the metadata URI"):
        let (metadata_player_len, metadata_player) = IERC721_metadata.tokenURI(
            contract_address=submited_exercise_address, token_id=token_id
        )
    end

    let (metadata_dummy_len, metadata_dummy) = IERC721_metadata.tokenURI(
        contract_address=dummy_metadata_erc721_address, token_id=token_id
    )
    with_attr error_message("Your token uri is not the same length as the dummy metadata"):
        # Verifying they are equal
        assert metadata_dummy_len = metadata_player_len
    end

    with_attr error_message("Your token uri is not the same as the dummy metadata"):
        ex7_check_arrays_are_equal(metadata_dummy_len, metadata_dummy, metadata_player)
    end
    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 7)

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 7)
        # Sending points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

@external
func submit_exercise{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    erc721_address : felt
):
    # Reading caller address
    let (sender_address) = get_caller_address()
    # Checking this contract was not used by another group before
    let (has_solution_been_submitted_before) = has_been_paired.read(erc721_address)
    with_attr error_message("Solution already submited"):
        assert has_solution_been_submitted_before = 0
    end

    # Assigning passed ERC721 as player ERC721
    player_exercise_solution_storage.write(sender_address, erc721_address)
    has_been_paired.write(erc721_address, 1)

    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 0)
    # This is necessary because of revoked references. Don't be scared, they won't stay around for too long...

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 0)
        # Sending points
        # setup points
        distribute_points(sender_address, 2)
        # Deploying contract points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

#
# Internal functions
#

func ex2a_get_animal_rank_internal{
    syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr
}(sender_address : felt):
    alloc_locals

    # Reading next available slot
    let (next_rank) = next_rank_storage.read()
    # Assigning to user
    assigned_rank_storage.write(sender_address, next_rank)

    let new_next_rank = next_rank + 1
    let (max_rank) = max_rank_storage.read()

    # Checking if we reach max_rank
    if new_next_rank == max_rank:
        next_rank_storage.write(0)
    else:
        next_rank_storage.write(new_next_rank)
    end
    return ()
end

func ex2b_test_declare_animal_internal{
    syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr
}(sender_address : felt, token_id : Uint256):
    alloc_locals
    # Retrieve expected characteristics
    let (expected_sex) = assigned_sex_number(sender_address)
    let (expected_legs) = assigned_legs_number(sender_address)
    let (expected_wings) = assigned_wings_number(sender_address)

    # Retrieve exercise address
    let (submited_exercise_address) = player_exercise_solution_storage.read(sender_address)
    # Get current contract address
    let (evaluator_address) = get_contract_address()
    # Reading who owns token 1 of exercise
    let (token_owner) = IERC721.ownerOf(
        contract_address=submited_exercise_address, token_id=token_id
    )

    with_attr error_message("Token 1 doesn't belong to the evaluator"):
        # Verifying that token 1 belongs to evaluator
        assert evaluator_address = token_owner
    end

    with_attr error_message("Couldn't retrieve the animal's characteristics"):
        # Reading animal characteristic in player solution
        let (read_sex, read_legs, read_wings) = IExerciceSolution.get_animal_characteristics(
            contract_address=submited_exercise_address, token_id=token_id
        )
    end

    # Checking characteristics are correct
    with_attr error_message("Wrong sex number"):
        assert read_sex = expected_sex
    end
    with_attr error_message("Wrong legs number"):
        assert read_legs = expected_legs
    end
    with_attr error_message("Wrong wings number"):
        assert read_wings = expected_wings
    end

    # Checking if player has validated this exercise before
    let (has_validated) = has_validated_exercise(sender_address, 2)

    if has_validated == 0:
        # player has validated
        validate_exercice(sender_address, 2)
        # Sending points
        distribute_points(sender_address, 2)
        return ()
    else:
        return ()
    end
end

func ex7_check_arrays_are_equal{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    arrays_len : felt, array_1 : felt*, array_2 : felt*
):
    if arrays_len == 0:
        return ()
    end
    ex7_check_arrays_are_equal(arrays_len=arrays_len - 1, array_1=array_1 + 1, array_2=array_2 + 1)
    with_attr error_message("Arrays are not equal on cell {arrays_len}"):
        assert [array_1] = [array_2]
    end
    return ()
end
#
# External functions - Administration
# Only admins can call these. You don't need to understand them to finish the exercice.
#

@external
func set_random_values{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    values_len : felt, values : felt*, column : felt
):
    # Check if the random values were already initialized
    let (was_initialized_read) = was_initialized.read()
    with_attr error_message("Random values already initialized"):
        assert was_initialized_read = 0
    end

    # Check that we fill max_ranK_storage cells
    let (max_rank) = max_rank_storage.read()
    assert values_len = max_rank

    # Storing passed values in the store
    set_a_random_value(values_len, values, column)

    return ()
end

@external
func finish_setup{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}():
    # Check if the random values were already initialized
    let (was_initialized_read) = was_initialized.read()
    with_attr error_message("Contract already initialized"):
        assert was_initialized_read = 0
    end
    # Mark that value store was initialized
    was_initialized.write(1)
    return ()
end

func set_a_random_value{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    values_len : felt, values : felt*, column : felt
):
    if values_len == 0:
        # Start with sum=0.
        return ()
    end

    set_a_random_value(values_len=values_len - 1, values=values + 1, column=column)
    random_attributes_storage.write(column, values_len - 1, [values])

    return ()
end