netcode throws hash errors when attempting to spawn local player

Hey,
Im currently working on a Relay connection with Netcode for Gameobjects. While the host-part seems to work, I'm still having some issues with the client. It can connect to the Relay and Host server, but when trying to spawn the local player, it throws these exeptions (at least theres 1 player spawned in, which is not the local player according to the networkObject):

Here's the code responsible for the Relay & Connecting logic:

 using UnityEngine;
 using Unity.Netcode;
 using UnityEngine.SceneManagement;
 using System.Threading.Tasks;
 using System;
 using Unity.Services.Core;
 using Unity.Services.Core.Environments;
 using Unity.Services.Authentication;
 using Unity.Services.Relay.Models;
 using Unity.Services.Relay;
 using TMPro;
 
 public struct RelayHostData
 {
     public string JoinCode;
     public string IPv4Address;
     public ushort Port;
     public Guid AllocationID;
     public byte[] AllocationIDBytes;
     public byte[] ConnectionData;
     public byte[] Key;
 } // Relevant stuff for host data
 public struct RelayJoinData
 {
     public string JoinCode;
     public string IPv4Address;
     public ushort Port;
     public Guid AllocationID;
     public byte[] AllocationIDBytes;
     public byte[] ConnectionData;
     public byte[] HostConnectionData;
     public byte[] Key;
 } // Relevant stuff for join data
 public class JoinManager : NetworkBehaviour
 {
     private enum gameStartMode {host, server, client, none}
     private gameStartMode mode = gameStartMode.none;
     [SerializeField] GameObject back;
     [SerializeField] NetworkObject player;
     [SerializeField] string JoinCode;
     [SerializeField] TMP_Text joinCodeField;
     #region relay
     [SerializeField] private string enviorment = "production";
     [SerializeField] private TMP_InputField input;
 
     [SerializeField] private int maxConnections = 10;
 
     [SerializeField] bool useRelay = true;
 
     public bool IsRelayEnabled => Transport != null && Transport.Protocol == UnityTransport.ProtocolType.RelayUnityTransport;
 
     public UnityTransport Transport => NetworkManager.Singleton.gameObject.GetComponent<UnityTransport>();
 
     public async Task<RelayHostData> SetupRelay()
     {
         print($"Relay Server Starting With " +
             $"Max Connections: {maxConnections}");
 
         InitializationOptions options = new InitializationOptions()
             .SetEnvironmentName(enviorment);
 
         await UnityServices.InitializeAsync(options);
 
         if (!AuthenticationService.Instance.IsSignedIn)
         {
             await AuthenticationService.Instance.SignInAnonymouslyAsync();
         }
 
         Allocation allocation = await Relay.Instance.CreateAllocationAsync(maxConnections);
 
         RelayHostData relayHostData = new RelayHostData
         {
             Key = allocation.Key,
             Port = (ushort)allocation.RelayServer.Port,
             AllocationID = allocation.AllocationId,
             AllocationIDBytes = allocation.AllocationIdBytes,
             IPv4Address = allocation.RelayServer.IpV4,
             ConnectionData = allocation.ConnectionData
         };
 
         relayHostData.JoinCode = await Relay.Instance.GetJoinCodeAsync(relayHostData.AllocationID);
 
         JoinCode = relayHostData.JoinCode;
 
         print($"The join code is {relayHostData.JoinCode}");
 
         Transport.SetRelayServerData(relayHostData.IPv4Address, relayHostData.Port, relayHostData.AllocationIDBytes,
                 relayHostData.Key, relayHostData.ConnectionData);
 
         print($"Relay Server Generated Join Code: {relayHostData.JoinCode}");
 
         return relayHostData;
     }
 
     public async Task<RelayJoinData> JoinRelay(string joinCode)
     {
 
         print($"Client Joining Game With Join Code: {joinCode}");
 
         InitializationOptions options = new InitializationOptions()
             .SetEnvironmentName(enviorment);
 
         await UnityServices.InitializeAsync(options);
 
         if (!AuthenticationService.Instance.IsSignedIn)
         {
             await AuthenticationService.Instance.SignInAnonymouslyAsync();
         }
 
         JoinAllocation allocation = await Relay.Instance.JoinAllocationAsync(joinCode);
 
         RelayJoinData relayJoinData = new RelayJoinData
         {
             Key = allocation.Key,
             Port = (ushort)allocation.RelayServer.Port,
             AllocationID = allocation.AllocationId,
             AllocationIDBytes = allocation.AllocationIdBytes,
             ConnectionData = allocation.ConnectionData,
             HostConnectionData = allocation.HostConnectionData,
             IPv4Address = allocation.RelayServer.IpV4,
             JoinCode = joinCode
         };
 
         Transport.SetRelayServerData(relayJoinData.IPv4Address, relayJoinData.Port, relayJoinData.AllocationIDBytes,
             relayJoinData.Key, relayJoinData.ConnectionData, relayJoinData.HostConnectionData);
 
         print($"Client joined game with code \"{joinCode} \" ");
 
         return relayJoinData;
     }
     #endregion
     private void Awake()
     {
         DontDestroyOnLoad(gameObject);
         SceneManager.sceneLoaded += OnGameLoaded;
     }
     private void Update()
     {
     }
     public void OnStartHost()
     {
         LoadGame();
         mode = gameStartMode.host;
     }
     public void OnStartServer()
     {
         LoadGame();
         mode = gameStartMode.server;
     }
     public void OnStartClient()
     {
         LoadGame();
         mode = gameStartMode.client;
     }
     void LoadGame()
     {
         SceneManager.LoadSceneAsync("Game Relay");
     }
     async void OnGameLoaded(Scene scene, LoadSceneMode lSM)
     {
         print($"IsRelayEnabled: {IsRelayEnabled}, useRelay: {useRelay}");
         if(scene == SceneManager.GetSceneByName("Game Relay"))
         {
             NetworkManager.Singleton.LogLevel = LogLevel.Normal;
             switch (mode)
             {
                 case gameStartMode.host:
                     if (IsRelayEnabled && useRelay)
                         if(IsRelayEnabled && useRelay)
                         {
                             print("Relay is enabled, starting host...");
 
 
                             await SetupRelay();
 
                             if (NetworkManager.Singleton.StartHost())
                             {
                                 print("successfuly started Host.");
                             }
                             else
                             {
                                 print("we are sorry, but an unexpected error occoured while trying to start a Host.");
                             }
                         }
                         else
                         {
                             print("Relay is not enabled, starting normaly");
                             NetworkManager.Singleton.StartHost();
                         }
 
                     break;
                 case gameStartMode.server:
                     NetworkManager.Singleton.StartServer();
                     break;
                 case gameStartMode.client:
                     if (IsRelayEnabled && !string.IsNullOrEmpty(input.text) && useRelay)
                     {
                         print("Relay is enabled, connecting as a client...");
                         await JoinRelay(input.text);
 
                         if (NetworkManager.Singleton.StartClient())
                             print("Client started.");
                         else
                             print("Unable to start client.");
                     }
                     else
                     {
                         print("Relay is not enabled, starting normaly");
                         NetworkManager.Singleton.StartHost();
                     }
 
                     break;
                 default:
                     return;
             }
             back.SetActive(false);
             joinCodeField.text = JoinCode;
         }
     }
 }
 

Edit: the Error seems to lie in other networkObjects