tests: add kakarot entrypoints tests (#1211)

<!--- Please provide a general summary of your changes in the title
above -->

<!-- Give an estimate of the time you spent on this PR in terms of work
days.
Did you spend 0.5 days on this PR or rather 2 days?  -->

Time spent on this PR: 0.2d

## Pull request type

<!-- Please try to limit your pull request to one type,
submit multiple pull requests if needed. -->

Please check the type of change your PR introduces:

- [ ] Bugfix
- [ ] Feature
- [ ] Code style update (formatting, renaming)
- [ ] Refactoring (no functional changes, no api changes)
- [ ] Build related changes
- [ ] Documentation content changes
- [ ] Other (please describe):

## What is the current behavior?

<!-- Please describe the current behavior that you are modifying,
or link to a relevant issue. -->

Resolves #1201

## What is the new behavior?

<!-- Please describe the behavior or changes that are being added by
this PR. -->

-
-
-

<!-- Reviewable:start -->
- - -
This change is [<img src="https://reviewable.io/review_button.svg"
height="34" align="absmiddle"
alt="Reviewable"/>](https://reviewable.io/reviews/kkrt-labs/kakarot/1211)
<!-- Reviewable:end -->

tests/src/kakarot/test_kakarot.cairo

@@ -5,6 +5,18 @@ from starkware.cairo.common.alloc import alloc
 from starkware.cairo.common.uint256 import Uint256
 
 from kakarot.library import Kakarot
+from kakarot.kakarot import (
+    register_account,
+    set_native_token,
+    set_base_fee,
+    set_coinbase,
+    set_prev_randao,
+    set_block_gas_limit,
+    set_account_contract_class_hash,
+    set_authorized_cairo_precompile_caller,
+    set_cairo1_helpers_class_hash,
+    transfer_ownership,
+)
 from kakarot.model import model
 from kakarot.account import Account
 
@@ -73,7 +85,100 @@ func test__register_account{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, rang
 
     %{ ids.evm_address = program_input["evm_address"] %}
 
-    Kakarot.register_account(evm_address=evm_address);
+    register_account(evm_address=evm_address);
 
     return ();
 }
+
+func test__transfer_ownership{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
+    tempvar new_owner;
+
+    %{ ids.new_owner = program_input["new_owner"] %}
+
+    transfer_ownership(new_owner);
+
+    return ();
+}
+
+func test__set_native_token{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
+    tempvar address;
+
+    %{ ids.address = program_input["address"] %}
+
+    set_native_token(address);
+    return ();
+}
+
+func test__set_coinbase{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
+    tempvar coinbase;
+
+    %{ ids.coinbase = program_input["coinbase"] %}
+
+    set_coinbase(coinbase);
+    return ();
+}
+
+func test__set_base_fee{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
+    tempvar base_fee;
+
+    %{ ids.base_fee = program_input["base_fee"] %}
+
+    set_base_fee(base_fee);
+    return ();
+}
+
+func test__set_prev_randao{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
+    tempvar prev_randao;
+
+    %{ ids.prev_randao = program_input["prev_randao"] %}
+
+    set_prev_randao(Uint256(prev_randao, 0));
+    return ();
+}
+
+func test__set_block_gas_limit{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() {
+    tempvar block_gas_limit;
+
+    %{ ids.block_gas_limit = program_input["block_gas_limit"] %}
+
+    set_block_gas_limit(block_gas_limit);
+    return ();
+}
+
+func test__set_account_contract_class_hash{
+    syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr
+}() {
+    tempvar value;
+
+    %{ ids.value = program_input["class_hash"] %}
+
+    set_account_contract_class_hash(value);
+    return ();
+}
+
+func test__set_authorized_cairo_precompile_caller{
+    syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr
+}() {
+    tempvar caller_address;
+    tempvar authorized;
+
+    %{
+        ids.caller_address = program_input["caller_address"]
+        ids.authorized = program_input["authorized"]
+    %}
+
+    set_authorized_cairo_precompile_caller(caller_address, authorized);
+
+    return ();
+}
+
+func test__set_cairo1_helpers_class_hash{
+    syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr
+}() {
+    tempvar value;
+
+    %{ ids.value = program_input["class_hash"] %}
+
+    set_cairo1_helpers_class_hash(value);
+    return ();
+}

tests/src/kakarot/test_kakarot.py

@@ -71,6 +71,141 @@ def _wrapper(self, *args, **kwargs):
 
 class TestKakarot:
 
+    class TestNativeToken:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run("test__set_native_token", address=0xABC)
+
+        @SyscallHandler.patch("Ownable_owner", SyscallHandler.caller_address)
+        def test_should_set_native_token(self, cairo_run):
+            token_address = 0xABCDE12345
+            cairo_run("test__set_native_token", address=token_address)
+            SyscallHandler.mock_storage.assert_any_call(
+                address=get_storage_var_address("Kakarot_native_token_address"),
+                value=token_address,
+            )
+
+    class TestTransferOwnership:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run("test__transfer_ownership", new_owner=0xABC)
+
+        @SyscallHandler.patch("Ownable_owner", SyscallHandler.caller_address)
+        def test_should_transfer_ownership(self, cairo_run):
+            new_owner = 0xABCDE12345
+            cairo_run("test__transfer_ownership", new_owner=new_owner)
+            SyscallHandler.mock_storage.assert_any_call(
+                address=get_storage_var_address("Ownable_owner"), value=new_owner
+            )
+
+    class TestBaseFee:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run("test__set_base_fee", base_fee=0xABC)
+
+        @SyscallHandler.patch("Ownable_owner", SyscallHandler.caller_address)
+        def test_should_set_base_fee(self, cairo_run):
+            base_fee = 0x100
+            cairo_run("test__set_base_fee", base_fee=base_fee)
+            SyscallHandler.mock_storage.assert_any_call(
+                address=get_storage_var_address("Kakarot_base_fee"), value=base_fee
+            )
+
+    class TestCoinbase:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run("test__set_coinbase", coinbase=0xABC)
+
+        @SyscallHandler.patch("Ownable_owner", SyscallHandler.caller_address)
+        def test_should_set_coinbase(self, cairo_run):
+            coinbase = 0xC0DE
+            cairo_run("test__set_coinbase", coinbase=coinbase)
+            SyscallHandler.mock_storage.assert_any_call(
+                address=get_storage_var_address("Kakarot_coinbase"), value=coinbase
+            )
+
+    class TestPrevRandao:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run("test__set_prev_randao", prev_randao=0xABC)
+
+        @SyscallHandler.patch("Ownable_owner", SyscallHandler.caller_address)
+        def test_should_set_prev_randao(self, cairo_run):
+            prev_randao = 0x123
+            cairo_run("test__set_prev_randao", prev_randao=prev_randao)
+            SyscallHandler.mock_storage.assert_any_call(
+                address=get_storage_var_address("Kakarot_prev_randao"),
+                value=prev_randao,
+            )
+
+    class TestBlockGasLimit:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run("test__set_block_gas_limit", block_gas_limit=0xABC)
+
+        @SyscallHandler.patch("Ownable_owner", SyscallHandler.caller_address)
+        def test_should_set_block_gas_limit(self, cairo_run):
+            block_gas_limit = 0x1000
+            cairo_run("test__set_block_gas_limit", block_gas_limit=block_gas_limit)
+            SyscallHandler.mock_storage.assert_any_call(
+                address=get_storage_var_address("Kakarot_block_gas_limit"),
+                value=block_gas_limit,
+            )
+
+    class TestAccountContractClassHash:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run("test__set_account_contract_class_hash", class_hash=0xABC)
+
+        @SyscallHandler.patch("Ownable_owner", SyscallHandler.caller_address)
+        def test_should_set_account_contract_class_hash(self, cairo_run):
+            class_hash = 0x123
+            cairo_run("test__set_account_contract_class_hash", class_hash=class_hash)
+            SyscallHandler.mock_storage.assert_any_call(
+                address=get_storage_var_address("Kakarot_account_contract_class_hash"),
+                value=class_hash,
+            )
+
+    class TestAuthorizedCairoPrecompileCaller:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run(
+                    "test__set_authorized_cairo_precompile_caller",
+                    caller_address=0xABC,
+                    authorized=0xBCD,
+                )
+
+        @SyscallHandler.patch("Ownable_owner", SyscallHandler.caller_address)
+        def test_should_set_authorized_cairo_precompile_caller(self, cairo_run):
+            caller = 0x123
+            authorized = 0x456
+            cairo_run(
+                "test__set_authorized_cairo_precompile_caller",
+                caller_address=caller,
+                authorized=authorized,
+            )
+            SyscallHandler.mock_storage.assert_any_call(
+                address=get_storage_var_address(
+                    "Kakarot_authorized_cairo_precompiles_callers",
+                    caller,
+                ),
+                value=authorized,
+            )
+
+    class Cairo1HelpersClass:
+        @SyscallHandler.patch("Ownable_owner", 0xDEAD)
+        def test_should_assert_only_owner(self, cairo_run):
+            with cairo_error():
+                cairo_run("test__set_cairo1_helpers_class_hash", class_hash=0xABC)
+
     class TestRegisterAccount:
         @SyscallHandler.patch("Kakarot_evm_to_starknet_address", EVM_ADDRESS, 0)
         @patch(