EIP-7748: State conversion to Verkle Tree

def apply_body(state: State, ...) -> Tuple[Uint, Root, Root, Bloom, State, Root]:
    ...
    # <new_code>
    if block_time >= CONVERSION_START_TIMESTAMP and not state._conversion_finished:
        block_state_conversion(state, CONVERSION_STRIDE)
    # </new_code>
    
    for i, tx in enumerate(map(decode_transaction, transactions)):
        ...
    ...

@dataclass
class StoragePhase:
    """
    The account next conversion step continues converting the 
    storage-slot with key greater or equal next_key. 
    If there isn't such storage-slot, the account must move to
    AccountDataPhase.
    """
    next_key: Bytes   
   
@dataclass
class AccountDataPhase:
    """
    The account next conversion step continues migrating the account 
    code (if any) and basic data. After processing, the account must 
    move to the next account in the trie (or finish if it was the 
    last one).
    """
    pass

@dataclass
class CurrentConvertingAccount:
    """
    Contains the state conversion next step.
    """
    address: Address
    phase : StoragePhase | AccountDataPhase

@dataclass
class State:
    # <new_code>
    _conversion_curr_account: Optional[CurrentConvertingAccount] = None
    _conversion_finished: bool = False
    # </new_code>
    ...
    

def trie_get_next_at_key(trie: Trie[K, V], key_seek: Bytes) -> (K, V, Optional[Bytes]):
    # Returns the first (key, value) in the trie-key is >= key_seek.
    # This method must only be used on Tries with secured=True,
    # since key_seek is the keccak256(K).
    # 
    # Returns:
    # - K, V: the key and value (e.g: Address/Value, StorageSlot/Value)
    # - next_key: The smallest trie-key present in the trie greater 
    # than key_seek, or None if there isn't one.
    #
    # Is up to the implementator to decide the best implementation
    # considering its client architecture.

# New function.
def get_conversion_account(state: State) -> CurrentConvertingAccount:
    # When starting the conversion, initialize with the first account
    # in the MPT.
    if state._conversion_curr_account is None:
        # Initialize with the first account in the account trie.
        first_account = trie_get_next_at_key("0x0")
        # Accounts conversion starts with storage-slots conversion.
        phase = StoragePhase("0x0") # Starts with the lowest storage-slot key.
        state._conversion_curr_account = CurrentConvertingAccount(first_account, phase)
    
    return state._conversion_curr_account

# New function.
def conversion_move_to_next_account(state: State):
    curr_account = state.get_conversion_account()
    address, _, next_key = trie_get_next_at_key(state._main_trie, curr_account.phase.next_key)
    if next_key is None:
        # We finished the conversion
        state._conversion_finished = True
    else:
        # Move to the next account
        state._conversion_curr_account.address = address
        state._conversion_curr_account.phase = StoragePhase("0x00")

# Modified function: add new only_if_empty optional parameter.
def set_storage(
    state: State, addr: Address, key: Bytes, value: U256, only_if_empty: bool = True
) -> None:
    # <new_code>
    if only_if_empty:
        value = state._overlay_tree.get(get_tree_key_for_storage_slot(addr, key))
        if value is not None:
            return
    # </new_code>
    
    state._overlay_tree.set(get_tree_key_for_storage_slot(addr, key), value)

# Note the following function is optimized for readability, not for performance.
def state_convert(state: State, stride: int):
    n = 0    
    while n < stride and not state._conversion_finished:
        curr_account = state.get_conversion_account()
        
        # EIP-161 should not be converted.
        if account_exists_and_is_empty(state, curr_account.address):
            state.conversion_move_to_next_account()
            continue
        
        # Account storage.
        if curr_account.phase is StoragePhase:
            # Get the storage-slot from _storage_tries which is MPT data.
            trie = state._storage_tries.get(curr_account.address)
            
            if trie is not None:
                slot_num, slot_value, next_key = trie_get_next_at_key(trie, curr_account.phase.next_key)
                # The Overlay Tree will write in the VKT. We use the new
                # only_if_empty parameter to avoid writing stale values.
                set_storage(state, curr_account.address, slot_num, slot_value, only_if_empty=True)
                n += 1
    
                if next_key is not None:
                    # There're more storage-slots to be converted, continue in this phase.
                    state.conversion_curr_account.phase.next_key = next_key
                else:
                    # No more storage-slots. Move to the account data migration.
                    state.conversion_curr_account.phase = AccountDataPhase()
            else:
                # There's no storage trie for the account, move directly to
                # migrating code (if any).
                state.conversion_curr_account.phase = AccountDataPhase()
        # Account code and basic data.
        else:
            # Getting the code from the Overlay Tree is fine since promises returning
            # the Account full code which would come from the MPT or a separate code database.
            account = get_account(state, curr_account.address)
            chunked_code = chunkify_code(account.code)
            
            for chunk_num in range(len(chunked_code)):
                state_set_codechunk(state, address, chunk_num, chunked_code[chunk_num])
                n += 1
                
            # If the account data (i.e: nonce, balance, code-size, code-hash) lives in MPT, 
            # get_account will pull from MPT and then we write to the VKT. If the account 
            # data already lives in the VKT (i.e: it was indirectly converted by a tx), then 
            # it will return it from the VKT and write it again (i.e: it's a noop).
            # Thus, this operation is correct under both scenarios. That is, it won't
            # write stale data.
            account = get_account(state, curr_account.address)
            set_account(state, curr_account.address, account)
            n += 1
    
            state.conversion_move_to_next_account()