public bool Invoke()
        {
            return Task.Run( async () => {

                try {

                    SteamID targetUser = new SteamID( "76561198129947779" );

                    SteamClient client = new SteamClient();
                    client.Authenticator = UserAuthenticator.ForProtectedResource( AccessConstants.OAuthAccessToken );

                    chatClient.SteamChatConnectionChanged += chatClient_SteamChatConnected;

                    chatClient.SteamChatMessagesReceived += chatClient_SteamChatMessagesReceived;
                    chatClient.SteamChatUserStateChange += chatClient_SteamChatUserStateChange;

                    chatClient.LogOn( client ).Wait();

                    while( true ) {
                        switch( WriteConsole.Prompt( "Command (msg, status): " ) ) {
                            case "msg": await chatClient.SendMessage( targetUser, WriteConsole.Prompt( "Type New Message: " ) ); break;
                            case "dcn": await chatClient.Disconnect(); break;
                        }
                    }

                } catch( Exception e ) {
                    WriteConsole.Error( e.Message + "\n" + e.ToString() );
                    return false;
                }

            } ).Result;
        }

        public void SteamIDEquals()
        {
            SteamID one = new SteamID( "76561198129947779" );
            SteamID two = new SteamID( "76561198129947779" );

            Assert.IsTrue( ( one == two ) );
        }

        public GameServerStatsGetUserStatIntResult GetUserStatInt(SteamID steamIDUser, string name)
        {
            GameServerStatsGetUserStatIntResult result = new GameServerStatsGetUserStatIntResult();

            result.Result = GetUserStat(steamIDUser, name, out result.IntValue);

            return result;
        }

        public void Update()
        {
            Callback callback;
            SteamCallHandle steamCall;

            if ( Steamworks.Steam_BGetCallback( pipe, out callback, out steamCall ) )
            {
                if ( callback.CallbackNum == FriendChatMsg.Callback )
                {
                    FriendChatMsg chatMsg = null;

                    try
                    {
                        chatMsg = ( FriendChatMsg )callback.CallbackObject;
                    }
                    catch
                    {
                        Steamworks.Steam_FreeLastCallback( pipe );
                        OnLogFailure( new LogFailureEventArgs( "Recieved callback was not in the correct format, call a programmer!" ) );
                        return;
                    }

                    string message = string.Empty;
                    FriendMsgType type;

                    SteamID reciever = new SteamID( chatMsg.Reciever );

                    steamFriends.GetChatMessage( reciever, ( int )chatMsg.ChatID, out message, 1024 * 4, out type );

                    LogMessage log = new LogMessage();

                    log.Sender = new SteamID( chatMsg.Sender );
                    log.SenderName = steamFriends.GetFriendPersonaName( log.Sender );

                    log.Reciever = reciever;
                    log.RecieverName = steamFriends.GetFriendPersonaName( log.Reciever );

                    log.Message = message;
                    log.MessageTime = DateTime.Now;
                    log.MessageType = type;

                    AddLog( log );
                }

                Steamworks.Steam_FreeLastCallback( pipe );
            }
        }

    //Thanks to Karl @ Stunlock Studios for giving me their function as he implemented utils.GetImage(Size/RGBA) into our library
    public Texture2D GetTextureFromSteamID(SteamID steamId)
    {
        IFriends friends = Steamworks.SteamInterface.Friends;
        IUtils utils = Steamworks.SteamInterface.Utils;

        ImageHandle avatarHandle = friends.GetLargeFriendAvatar(steamId);
        if (avatarHandle.IsValid)
        {
            uint width, height;
            if (utils.GetImageSize(avatarHandle, out width, out height))
            {
                Texture2D texture = new Texture2D((int)width, (int)height, TextureFormat.RGBA32, true);
                Color32[] buffer = new Color32[width * height];

                GCHandle bufferHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);

                try
                {
                    System.IntPtr bufferPtr = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0);

                    if (utils.GetImageRGBA(avatarHandle, bufferPtr, (int)width * (int)height * 4))
                    {
                        // Flip vertical
                        for (int x = 0; x < width; x++)
                        {
                            for (int y = 0; y < height / 2; y++)
                            {
                                Color32 temp = buffer[x + (width * y)];
                                buffer[x + (width * y)] = buffer[x + (width * (height - 1 - y))];
                                buffer[x + (width * (height - 1 - y))] = temp;
                            }
                        }

                        texture.SetPixels32(buffer);
                        texture.Apply();
                    }
                }
                finally
                {
                    bufferHandle.Free();
                }
                return texture;
            }
        }

        return null;
    }

        /// <summary>
        /// Invokes LeaderboardScoresDownloaded
        /// </summary>
        /// <param name="handle"></param>
        /// <param name="users"></param>
        public void DownloadLeaderboardEntriesForUsers(LeaderboardHandle handle, SteamID[] users)
        {
            CheckIfUsable();
            // We need to first convert the array of SteamID objects to a byte array
            byte[] rawData = NativeBuffer.ToBytes(users);

            using (NativeBuffer buffer = new NativeBuffer(rawData))
            {
                // Copies the list of user ID's to unmanaged memory
                buffer.WriteToUnmanagedMemory();

                NativeMethods.Stats_DownloadLeaderboardEntriesForUsers(handle.AsUInt64,
                    buffer.UnmanagedMemory, users.Length);
            }
        }

 /// <summary>
 /// Invokes UserStatsReceived
 /// </summary>
 /// <param name="steamID"></param>
 public void RequestUserStats(SteamID steamID)
 {
     CheckIfUsable();
     NativeMethods.Stats_RequestUserStats(steamID.AsUInt64);
 }

        void HandleLogOnResponse( IPacketMsg packetMsg )
        {
            if ( !packetMsg.IsProto )
            {
                DebugLog.WriteLine( "CMClient", "Got non-proto logon response, this is indicative of no logon attempt after connecting." );
                return;
            }

            var logonResp = new ClientMsgProtobuf<CMsgClientLogonResponse>( packetMsg );

            if ( logonResp.Body.eresult == ( int )EResult.OK )
            {
                SessionID = logonResp.ProtoHeader.client_sessionid;
                SteamID = logonResp.ProtoHeader.steamid;

                int hbDelay = logonResp.Body.out_of_game_heartbeat_seconds;

                // restart heartbeat
                heartBeatFunc.Stop();
                heartBeatFunc.Delay = TimeSpan.FromSeconds( hbDelay );
                heartBeatFunc.Start();
            }
        }

 public bool SetLobbyJoinable(SteamID steamIDLobby, bool lobbyJoinable)
 {
     CheckIfUsable();
     return NativeMethods.MatchMaking_SetLobbyJoinable(steamIDLobby.AsUInt64, lobbyJoinable);
 }

 public UserHasLicenseForAppResult UserHasLicenseForApp(SteamID steamID, AppID appID)
 {
     //CheckIfUsable();
     int tempreturn = NativeMethods.GameServer_UserHasLicenseForApp(steamID.AsUInt64, appID.AsUInt32);
     return (UserHasLicenseForAppResult)tempreturn;
 }

 public void AssociateWithClan(SteamID steamIDClan)
 {
     //CheckIfUsable();
     NativeMethods.GameServer_AssociateWithClan(steamIDClan.AsUInt64);
 }

 public void SendUserDisconnect(SteamID steamIDUser)
 {
     //CheckIfUsable();
     NativeMethods.GameServer_SendUserDisconnect(steamIDUser.AsUInt64);
 }

 public BeginAuthSessionResult BeginAuthSession(System.IntPtr authTicket, int cbAuthTicket, SteamID steamID)
 {
     //CheckIfUsable();
     return (BeginAuthSessionResult)NativeMethods.GameServer_BeginAuthSession(authTicket, cbAuthTicket, steamID.AsUInt64);
 }

        public JKAConfig GetUserConfig(SteamID id)
        {
            if (configCache.ContainsKey(id))
            {
                return configCache[id];
            }

            return JKAConfig.FromSteamID(id, folderPrefix);
        }

 public bool RequestLobbyData(SteamID steamIDLobby)
 {
     CheckIfUsable();
     return NativeMethods.MatchMaking_RequestLobbyData(steamIDLobby.AsUInt64);
 }

 public bool SetLinkedLobby(SteamID steamIDLobby, SteamID steamIDLobbyDependent)
 {
     CheckIfUsable();
     return NativeMethods.MatchMaking_SetLobbyOwner(steamIDLobby.AsUInt64, steamIDLobbyDependent.AsUInt64);
 }

 public bool SetLobbyOwner(SteamID steamIDLobby, SteamID steamIDNewOwner)
 {
     CheckIfUsable();
     return NativeMethods.MatchMaking_SetLobbyOwner(steamIDLobby.AsUInt64, steamIDNewOwner.AsUInt64);
 }

 public SteamID GetLobbyOwner(SteamID steamIDLobby)
 {
     CheckIfUsable();
     return new SteamID(NativeMethods.MatchMaking_GetLobbyOwner(steamIDLobby.AsUInt64));
 }

        public bool SendUserConnectAndAuthenticate(uint ipClient, byte[] authenticationBlob, out SteamID steamIDUser)
        {
            //CheckIfUsable();

            using (NativeBuffer blobBuffer = new NativeBuffer(authenticationBlob))
            {
                blobBuffer.WriteToUnmanagedMemory();
                ulong rawCreator = 0;
                bool result = NativeMethods.GameServer_SendUserConnectAndAuthenticate(ipClient,
                    blobBuffer.UnmanagedMemory, (uint)blobBuffer.UnmanagedMemory, ref rawCreator);

                steamIDUser = new SteamID(rawCreator);
                return result;

            }

        }

 public bool GetUserStat(SteamID steamID, string name, out float data)
 {
     CheckIfUsable();
     data = 0;
     return NativeMethods.Stats_GetUserStatFloat(steamID.AsUInt64, name, ref data);
 }