generic_account -> account_contract

Author: enitrat

.github/workflows/ci.yml

@@ -168,7 +168,6 @@ jobs:
         uses: actions/checkout@v3
         with:
           repository: kkrt-labs/ef-tests
-          ref: refactor/rename-storage-vars
       - name: Checkout local skip file
         uses: actions/checkout@v3
         with:

docs/general/decode_a_cairo_trace.md

@@ -89,7 +89,7 @@ from starkware.cairo.lang.vm.reconstruct_traceback import reconstruct_traceback
 
 build_dir = Path("build")
 programs = {}
-for contract_name in ["uninitialized_account", "kakarot", "generic_account", "EVM"]:
+for contract_name in ["uninitialized_account", "kakarot", "account_contract", "EVM"]:
     artifact = build_dir / f"{contract_name}.json"
     if not artifact.is_file():
         artifact = build_dir / "fixtures" / f"{contract_name}.json"

kakarot_scripts/constants.py

@@ -155,7 +155,7 @@ class ArtifactType(Enum):
 
 COMPILED_CONTRACTS = [
     {"contract_name": "kakarot", "is_account_contract": False},
-    {"contract_name": "generic_account", "is_account_contract": True},
+    {"contract_name": "account_contract", "is_account_contract": True},
     {"contract_name": "uninitialized_account", "is_account_contract": False},
     {"contract_name": "EVM", "is_account_contract": False},
     {"contract_name": "OpenzeppelinAccount", "is_account_contract": True},
@@ -164,7 +164,7 @@ class ArtifactType(Enum):
 ]
 DECLARED_CONTRACTS = [
     {"contract_name": "kakarot", "cairo_version": ArtifactType.cairo0},
-    {"contract_name": "generic_account", "cairo_version": ArtifactType.cairo0},
+    {"contract_name": "account_contract", "cairo_version": ArtifactType.cairo0},
     {"contract_name": "uninitialized_account", "cairo_version": ArtifactType.cairo0},
     {"contract_name": "EVM", "cairo_version": ArtifactType.cairo0},
     {"contract_name": "OpenzeppelinAccount", "cairo_version": ArtifactType.cairo0},

kakarot_scripts/deploy_kakarot.py

@@ -56,7 +56,7 @@ async def main():
             "kakarot",
             account.address,  # owner
             ETH_TOKEN_ADDRESS,  # native_token_address_
-            class_hash["generic_account"],  # generic_account_class_hash_
+            class_hash["account_contract"],  # account_contract_class_hash_
             class_hash["uninitialized_account"],  # uninitialized_account_class_hash_
             class_hash["Precompiles"],
             BLOCK_GAS_LIMIT,
@@ -66,7 +66,7 @@ async def main():
         deployments["EVM"] = await deploy(
             "EVM",
             ETH_TOKEN_ADDRESS,  # native_token_address_
-            class_hash["generic_account"],  # generic_account_class_hash_
+            class_hash["account_contract"],  # account_contract_class_hash_
             class_hash["uninitialized_account"],  # uninitialized_account_class_hash_
             class_hash["Precompiles"],
             BLOCK_GAS_LIMIT,

kakarot_scripts/utils/kakarot.py

@@ -451,7 +451,7 @@ async def eth_get_code(address: Union[int, str]):
     return bytes(
         (
             await _call_starknet(
-                "generic_account", "bytecode", address=starknet_address
+                "account_contract", "bytecode", address=starknet_address
             )
         ).bytecode
     )

src/backend/starknet.cairo

@@ -28,7 +28,7 @@ from kakarot.model import model
 from kakarot.state import State
 from kakarot.storages import (
     Kakarot_native_token_address,
-    Kakarot_generic_account_class_hash,
+    Kakarot_account_contract_class_hash,
     Kakarot_uninitialized_account_class_hash,
     Kakarot_evm_to_starknet_address,
     Kakarot_coinbase,
@@ -86,7 +86,7 @@ namespace Starknet {
         );
 
         // Properly initialize the account once created
-        let (account_class_hash) = Kakarot_generic_account_class_hash.read();
+        let (account_class_hash) = Kakarot_account_contract_class_hash.read();
         IUninitializedAccount.initialize(starknet_address, account_class_hash);
 
         evm_contract_deployed.emit(evm_address, starknet_address);

src/kakarot/account.cairo

@@ -26,7 +26,7 @@ from kakarot.constants import Constants
 from kakarot.storages import (
     Kakarot_uninitialized_account_class_hash,
     Kakarot_native_token_address,
-    Kakarot_generic_account_class_hash,
+    Kakarot_account_contract_class_hash,
 )
 from kakarot.interfaces.interfaces import IAccount, IERC20
 from kakarot.model import model
@@ -630,7 +630,7 @@ namespace Account {
 namespace Internals {
     // @notice Compute the storage address of the given key when the storage var interface is
     //         Account_storage(key: Uint256)
-    // @dev    Just the generated addr method when compiling the generic_account
+    // @dev    Just the generated addr method when compiling the account_contract
     func _storage_addr{pedersen_ptr: HashBuiltin*, range_check_ptr}(key: Uint256*) -> (res: felt) {
         let res = 0x0127c52d6fa812547d8a5b435341b8c12e82048913e7193c0e318e8a6642876d;
         let (res) = hash2{hash_ptr=pedersen_ptr}(res, cast(key, felt*)[0]);

src/kakarot/accounts/generic_account.cairo renamed to src/kakarot/accounts/account_contract.cairo

@@ -8,7 +8,7 @@ from starkware.cairo.common.cairo_builtins import HashBuiltin, BitwiseBuiltin, S
 from starkware.cairo.common.uint256 import Uint256
 
 // Local dependencies
-from kakarot.accounts.library import GenericAccount
+from kakarot.accounts.library import AccountContract
 from starkware.starknet.common.syscalls import get_tx_info, get_caller_address
 from starkware.cairo.common.math import assert_le, unsigned_div_rem
 from starkware.cairo.common.alloc import alloc
@@ -31,8 +31,8 @@ func constructor{
 @external
 func initialize{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*
-}(kakarot_address: felt, evm_address: felt, implementation_class: felt) {
-    return GenericAccount.initialize(kakarot_address, evm_address, implementation_class);
+}(implementation_class: felt) {
+    return AccountContract.initialize(implementation_class);
 }
 
 // @notice replaces the class of the account.
@@ -41,7 +41,7 @@ func initialize{
 func upgrade{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*
 }(new_class: felt) {
-    return GenericAccount.upgrade(new_class);
+    return AccountContract.upgrade(new_class);
 }
 
 // @notice Gets the evm address associated with the account.
@@ -50,7 +50,7 @@ func upgrade{
 func get_evm_address{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (
     address: felt
 ) {
-    return GenericAccount.get_evm_address();
+    return AccountContract.get_evm_address();
 }
 
 // @notice Checks if the account was initialized.
@@ -59,7 +59,7 @@ func get_evm_address{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check
 func is_initialized{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*
 }() -> (is_initialized: felt) {
-    return GenericAccount.is_initialized();
+    return AccountContract.is_initialized();
 }
 
 // EOA specific entrypoints
@@ -74,9 +74,12 @@ func is_initialized{
 func __validate__{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, bitwise_ptr: BitwiseBuiltin*, range_check_ptr
 }(
-    call_array_len: felt, call_array: GenericAccount.CallArray*, calldata_len: felt, calldata: felt*
+    call_array_len: felt,
+    call_array: AccountContract.CallArray*,
+    calldata_len: felt,
+    calldata: felt*,
 ) {
-    GenericAccount.validate(
+    AccountContract.validate(
         call_array_len=call_array_len,
         call_array=call_array,
         calldata_len=calldata_len,
@@ -114,7 +117,10 @@ func __execute__{
     bitwise_ptr: BitwiseBuiltin*,
     range_check_ptr,
 }(
-    call_array_len: felt, call_array: GenericAccount.CallArray*, calldata_len: felt, calldata: felt*
+    call_array_len: felt,
+    call_array: AccountContract.CallArray*,
+    calldata_len: felt,
+    calldata: felt*,
 ) -> (response_len: felt, response: felt*) {
     alloc_locals;
     let (tx_info) = get_tx_info();
@@ -128,8 +134,12 @@ func __execute__{
         assert caller = 0;
     }
 
+    with_attr error_message("EOA: multicall not supported") {
+        assert call_array_len = 1;
+    }
+
     let (local response: felt*) = alloc();
-    let (response_len) = GenericAccount.execute(
+    let (response_len) = AccountContract.execute(
         call_array_len=call_array_len,
         call_array=call_array,
         calldata_len=calldata_len,
@@ -146,7 +156,7 @@ func __execute__{
 func write_bytecode{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*
 }(bytecode_len: felt, bytecode: felt*) {
-    return GenericAccount.write_bytecode(bytecode_len, bytecode);
+    return AccountContract.write_bytecode(bytecode_len, bytecode);
 }
 
 // @notice This function is used to get the bytecode of the smart contract.
@@ -156,7 +166,7 @@ func write_bytecode{
 func bytecode{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*
 }() -> (bytecode_len: felt, bytecode: felt*) {
-    return GenericAccount.bytecode();
+    return AccountContract.bytecode();
 }
 
 // @notice This function is used to get only the bytecode_len of the smart contract.
@@ -166,7 +176,7 @@ func bytecode{
 func bytecode_len{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*
 }() -> (len: felt) {
-    let (len) = GenericAccount.bytecode_len();
+    let (len) = AccountContract.bytecode_len();
     return (len=len);
 }
 
@@ -177,7 +187,7 @@ func bytecode_len{
 func write_storage{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*
 }(storage_addr: felt, value: Uint256) {
-    return GenericAccount.write_storage(storage_addr, value);
+    return AccountContract.write_storage(storage_addr, value);
 }
 
 // @notice Read a given storage key
@@ -187,18 +197,18 @@ func write_storage{
 func storage{
     syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*
 }(storage_addr: felt) -> (value: Uint256) {
-    return GenericAccount.storage(storage_addr);
+    return AccountContract.storage(storage_addr);
 }
 
 // @notice This function is used to read the nonce from storage
 // @return nonce The current nonce of the contract account
 @view
 func get_nonce{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (nonce: felt) {
-    return GenericAccount.get_nonce();
+    return AccountContract.get_nonce();
 }
 
 // @notice This function set the contract account nonce
 @external
 func set_nonce{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(nonce: felt) {
-    return GenericAccount.set_nonce(nonce);
+    return AccountContract.set_nonce(nonce);
 }

src/kakarot/accounts/library.cairo

@@ -25,6 +25,7 @@ from starkware.starknet.common.syscalls import (
 )
 from starkware.cairo.common.memset import memset
 
+from kakarot.accounts.shared_storage import Account_evm_address, Account_kakarot_address
 from kakarot.interfaces.interfaces import IERC20, IKakarot
 from kakarot.errors import Errors
 from kakarot.constants import Constants
@@ -43,10 +44,6 @@ func Account_storage(key: Uint256) -> (value: Uint256) {
 func Account_is_initialized() -> (res: felt) {
 }
 
-@storage_var
-func Account_evm_address() -> (evm_address: felt) {
-}
-
 @storage_var
 func Account_nonce() -> (nonce: felt) {
 }
@@ -64,16 +61,21 @@ const BYTES_PER_FELT = 31;
 // @title Account main library file.
 // @notice This file contains the EVM account representation logic.
 // @dev: Both EOAs and Contract Accounts are represented by this contract.
-namespace GenericAccount {
+namespace AccountContract {
     // @notice This function is used to initialize the smart contract account.
+    // @dev The `evm_address` and `kakarot_address` were set during the uninitialized_account creation.
+    // Reading them from state ensures that they always match the ones the account was created for.
     func initialize{
         syscall_ptr: felt*,
         pedersen_ptr: HashBuiltin*,
         range_check_ptr,
         bitwise_ptr: BitwiseBuiltin*,
-    }(kakarot_address: felt, evm_address: felt, implementation_class: felt) {
+    }(implementation_class: felt) {
+        alloc_locals;
         let (is_initialized) = Account_is_initialized.read();
         assert is_initialized = 0;
+        let (kakarot_address) = Account_kakarot_address.read();
+        let (evm_address) = Account_evm_address.read();
         Account_is_initialized.write(1);
         Ownable.initializer(kakarot_address);
         Account_evm_address.write(evm_address);
@@ -229,6 +231,22 @@ namespace GenericAccount {
 
         let tx = EthTransaction.decode([call_array].data_len, calldata + [call_array].data_offset);
 
+        // No matter the status of the execution in EVM terms (success - failure - rejected), the nonce of the
+        // transaction sender must be incremented, as the protocol nonce is.  While we use the protocol nonce for the
+        // transaction validation, we don't make the distinction between CAs and EOAs in their
+        // Starknet contract representation. As such, the stored nonce of an EOA account must always match the
+        // protocol nonce, increased by one right before each transaction execution.
+        //
+        // In the official specification, this nonce increment is done right after the tx validation checks.
+        // Since we can only perform these checks in __execute__, which increments the protocol nonce by one,
+        // we need to increment the stored nonce here as well.
+        //
+        // The protocol nonce is updated once per __execute__ call, while the EVM nonce is updated once per
+        // transaction. If we were to execute more than one transaction in a single __execute__ call, we would
+        // need to change the nonce incrementation logic.
+        let (current_nonce) = Account_nonce.read();
+        Account_nonce.write(current_nonce + 1);
+
         let (kakarot_address) = Ownable_owner.read();
         let (block_gas_limit) = IKakarot.get_block_gas_limit(kakarot_address);
         let tx_gas_fits_in_block = is_le(tx.gas_limit, block_gas_limit);
@@ -303,14 +321,6 @@ namespace GenericAccount {
             response_len=return_data_len, response=return_data, success=success, gas_used=gas_used
         );
 
-        // No matter the status of the execution (success - failure - rejected), the nonce of the
-        // transaction sender must be incremented.  While we use the protocol nonce for the
-        // transaction validation, we don't make the distinction between CAs and EOAs in their
-        // Starknet contract representation. As such, the stored nonce of an EOA account must be
-        // increased by one after each execution.
-        let (current_nonce) = Account_nonce.read();
-        Account_nonce.write(current_nonce + 1);
-
         let (response_len) = execute(
             call_array_len - 1,
             call_array + CallArray.SIZE,

src/kakarot/accounts/shared_storage.cairo

@@ -0,0 +1,13 @@
+%lang starknet
+
+// We are intentionally causing a storage_slot collision here,
+// by importing these variables in both `uninitialized_account` and `account_contract`.
+// We are defining them here instead of in the account library, so as to not depend
+// on content of the account library in uninitialized_account and ensure a fixed class hash.
+@storage_var
+func Account_evm_address() -> (evm_address: felt) {
+}
+
+@storage_var
+func Account_kakarot_address() -> (kakarot_address: felt) {
+}