EIP-7748: 状态转换为 Verkle 树

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:
    """
    账户的下一个转换步骤继续转换存储槽，
    其键大于等于 next_key。
    如果没有这样的存储槽，则账户必须移动到
    AccountDataPhase。
    """
    next_key: Bytes   
   
@dataclass
class AccountDataPhase:
    """
    账户的下一个转换步骤继续迁移账户
    代码（如果有）和基本数据。处理后，账户必须
    移动到 trie 中的下一个账户（如果它是
    最后一个）。
    """
    pass

@dataclass
class CurrentConvertingAccount:
    """
    包含状态转换的下一步骤。
    """
    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]):
    # 返回 trie 中第一个 (key, value)，其中 trie-key >= key_seek。
    # 此方法只能在 secured=True 的 Trie 上使用，
    # 因为 key_seek 是 keccak256(K)。
    # 
    # 返回：
    # - K, V: 键和值（例如：地址/值，存储槽/值）
    # - next_key: trie 中存在的最小 trie-key，大于
    # key_seek，如果没有，则为 None。
    #
    # 由实现者决定最佳实现方式
    # 考虑到其客户端架构。

# 新函数。
def get_conversion_account(state: State) -> CurrentConvertingAccount:
    # 启动转换时，使用 MPT 中的第一个账户初始化。
    if state._conversion_curr_account is None:
        # 使用账户 trie 中的第一个账户初始化。
        first_account = trie_get_next_at_key("0x0")
        # 账户转换从存储槽转换开始。
        phase = StoragePhase("0x0") # 从最低的存储槽键开始。
        state._conversion_curr_account = CurrentConvertingAccount(first_account, phase)
    
    return state._conversion_curr_account

# 新函数。
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:
        # 我们完成了转换
        state._conversion_finished = True
    else:
        # 移动到下一个账户
        state._conversion_curr_account.address = address
        state._conversion_curr_account.phase = StoragePhase("0x00")

# 修改后的函数：添加新的 only_if_empty 可选参数。
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)

# 请注意，以下函数针对可读性进行了优化，而不是针对性能进行了优化。
def state_convert(state: State, stride: int):
    n = 0    
    while n < stride and not state._conversion_finished:
        curr_account = state.get_conversion_account()
        
        # 如果账户具有空的 code hash，则跳过翻译存储。
        # 跳过 nonce 为 0 且代码为空的账户的存储转换。
        # 这涵盖了 28 个 EIP-7610 账户，但也涵盖了所有
        # 其他链上的 pre-eip161 账户。
        if cur_account.nonce == 0 and len(cur_account.code) == 0:
            state._conversion_curr_account.phase = AccountDataPhase()
        
        # 账户存储。
        if curr_account.phase is StoragePhase:
            # 从 _storage_tries 中获取存储槽，它是 MPT 数据。
            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)
                # Overlay Tree 将写入 VKT。我们使用新的
                # only_if_empty 参数来避免写入过时的值。
                set_storage(state, curr_account.address, slot_num, slot_value, only_if_empty=True)
                n += 1
    
                if next_key is not None:
                    # 还有更多的存储槽要转换，在此阶段继续。
                    state.conversion_curr_account.phase.next_key = next_key
                else:
                    # 没有更多的存储槽。移动到账户数据迁移。
                    state.conversion_curr_account.phase = AccountDataPhase()
            else:
                # 账户没有存储 trie，直接移动到
                # 迁移账户的数据和代码（如果有）。
                state.conversion_curr_account.phase = AccountDataPhase()
        # 账户代码和基本数据。
        else:
            # 从 Overlay Tree 获取代码是可以的，因为它承诺返回
            # 账户的完整代码，该代码将来自 MPT 或单独的代码数据库。
            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])
                
            # 如果账户数据（即：nonce、balance、code-size、code-hash）存在于 MPT 中，
            # get_account 将从 MPT 中提取，然后我们写入到 VKT。如果账户
            # 数据已经存在于 VKT 中（即：它是由 tx 间接转换的），那么
            # 它将从 VKT 返回并再次写入（即：它是 noop）。
            # 因此，此操作在两种情况下都是正确的。也就是说，它不会
            # 写入过时的数据。
            account = get_account(state, curr_account.address)
            set_account(state, curr_account.address, account)
            n += 1
    
            state.conversion_move_to_next_account()