<snip>

    return (

        len(code) == EOA_DELEGATED_CODE_LENGTH

        and code[:EOA_DELEGATION_MARKER_LENGTH] == EOA_DELEGATION_MARKER

    )

    <snip>

    if is_valid_delegation(code):

        return Address(code[EOA_DELEGATION_MARKER_LENGTH:])

    return None

    <snip>

    y_parity, r, s = authorization.y_parity, authorization.r, authorization.s

    if y_parity not in (0, 1):

        raise InvalidSignatureError("Invalid y_parity in authorization")

    if U256(0) >= r or r >= SECP256K1N:

        raise InvalidSignatureError("Invalid r value in authorization")

    if U256(0) >= s or s > SECP256K1N // U256(2):

        raise InvalidSignatureError("Invalid s value in authorization")

    signing_hash = keccak256(

        SET_CODE_TX_MAGIC

        + rlp.encode(

            (

                authorization.chain_id,

                authorization.address,

                authorization.nonce,

            )

        )

    )

    public_key = secp256k1_recover(r, s, U256(y_parity), signing_hash)

    return Address(keccak256(public_key)[12:32])

    <snip>

    tx_state = evm.message.tx_env.state

    code = get_code(tx_state, get_account(tx_state, address).code_hash)

    if not is_valid_delegation(code):

        return False, address, Uint(0)

    delegated_address = Address(code[EOA_DELEGATION_MARKER_LENGTH:])

    if delegated_address in evm.accessed_addresses:

        delegation_gas_cost = GasCosts.WARM_ACCESS

    else:

        delegation_gas_cost = GasCosts.COLD_ACCOUNT_ACCESS

    return True, delegated_address, delegation_gas_cost

    <snip>

    tx_state = message.tx_env.state

    if auth.chain_id not in (message.block_env.chain_id, U256(0)):

        return None

    if auth.nonce >= U64.MAX_VALUE:

        return None

    try:

        authority = recover_authority(auth)

    except InvalidSignatureError:

        return None

    message.accessed_addresses.add(authority)

    authority_account = get_account(tx_state, authority)

    authority_code = get_code(tx_state, authority_account.code_hash)

    if authority_code and not is_valid_delegation(authority_code):

        return None

    authority_nonce = authority_account.nonce

    if authority_nonce != auth.nonce:

        return None

    return authority

    <snip>

    message = evm.message

    tx_state = message.tx_env.state

    # Accounts whose write the transaction has already priced: the

    # sender's leaf was written at inclusion (nonce bump and fee

    # deduction), and a value-bearing transaction prepays the

    # recipient's balance write -- the transfer itself only happens at

    # frame entry, after these charges.

    written_accounts: Set[Address] = {message.tx_env.origin}

    if evm.message.tx_env.value > U256(0):

        written_accounts.add(evm.message.current_target)

    # Authorities a delegation was set for earlier in this transaction.

    delegation_set_for: Set[Address] = set()

    for auth in message.tx_env.authorizations:

        match validate_authorization(message, auth):

            case None:

                continue

            case authority:

                pass

        if not account_exists(tx_state, authority):

            charge_state_gas(evm, StateGasCosts.NEW_ACCOUNT)

        if authority not in written_accounts:

            charge_gas(evm, GasCosts.ACCOUNT_WRITE)

            written_accounts.add(authority)

        pre_state_authority_account = get_pre_state_account(

            tx_state, authority

        )

        pre_state_authority_code = get_code(

            tx_state, pre_state_authority_account.code_hash

        )

        delegated_before_tx = is_valid_delegation(pre_state_authority_code)

        if auth.address == NULL_ADDRESS:

            code_to_set = b""

        else:

            if not delegated_before_tx and authority not in delegation_set_for:

                charge_state_gas(evm, StateGasCosts.AUTH_BASE)

            delegation_set_for.add(authority)

            code_to_set = EOA_DELEGATION_MARKER + auth.address

        set_code(tx_state, authority, code_to_set)

        increment_nonce(tx_state, authority)