Fix awaiting null tasks, closes #128

Mark is untested yet

.gitignore

@@ -4,8 +4,8 @@
 
 # Ignore all config files, apart from ones we want to include
 ArchiSteamFarm/config/*
-!ArchiSteamFarm/config/example.xml
-!ArchiSteamFarm/config/minimal.xml
+!ArchiSteamFarm/config/example.json
+!ArchiSteamFarm/config/minimal.json
 
 # Ignore local debugging log file
 ArchiSteamFarm/log.txt

ArchiSteamFarm/ArchiHandler.cs

@@ -24,9 +24,11 @@
 
 using SteamKit2;
 using SteamKit2.Internal;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Net;
+using System.Threading.Tasks;
 
 namespace ArchiSteamFarm {
 	internal sealed class ArchiHandler : ClientMsgHandler {
@@ -41,9 +43,11 @@ namespace ArchiSteamFarm {
 
 		internal sealed class NotificationsCallback : CallbackMsg {
 			internal sealed class Notification {
-				internal enum ENotificationType {
+				internal enum ENotificationType : uint {
 					Unknown = 0,
 					Trading = 1,
+					// Only custom below, different than ones available as user_notification_type
+					Items = 514
 				}
 
 				internal ENotificationType NotificationType { get; set; }
@@ -54,17 +58,31 @@ namespace ArchiSteamFarm {
 			internal NotificationsCallback(JobID jobID, CMsgClientUserNotifications msg) {
 				JobID = jobID;
 
-				if (msg == null) {
+				if (msg == null || msg.notifications == null) {
 					return;
 				}
 
-				Notifications = new List<Notification>();
+				Notifications = new List<Notification>(msg.notifications.Count);
 				foreach (var notification in msg.notifications) {
 					Notifications.Add(new Notification {
 						NotificationType = (Notification.ENotificationType) notification.user_notification_type
 					});
 				}
 			}
+
+			internal NotificationsCallback(JobID jobID, CMsgClientItemAnnouncements msg) {
+				JobID = jobID;
+
+				if (msg == null) {
+					return;
+				}
+
+				if (msg.count_new_items > 0) {
+					Notifications = new List<Notification>(1) {
+						new Notification { NotificationType = Notification.ENotificationType.Items }
+					};
+				}
+			}
 		}
 
 		internal sealed class OfflineMessageCallback : CallbackMsg {
@@ -200,7 +218,7 @@ namespace ArchiSteamFarm {
 			Client.Send(request);
 		}
 
-		internal AsyncJob<PurchaseResponseCallback> RedeemKey(string key) {
+		internal async Task<PurchaseResponseCallback> RedeemKey(string key) {
 			if (string.IsNullOrEmpty(key) || !Client.IsConnected) {
 				return null;
 			}
@@ -212,7 +230,12 @@ namespace ArchiSteamFarm {
 			request.Body.key = key;
 
 			Client.Send(request);
-			return new AsyncJob<PurchaseResponseCallback>(Client, request.SourceJobID);
+			try {
+				return await new AsyncJob<PurchaseResponseCallback>(Client, request.SourceJobID);
+			} catch (Exception e) {
+				Logging.LogGenericException(e);
+				return null;
+			}
 		}
 
 		/*
@@ -233,6 +256,9 @@ namespace ArchiSteamFarm {
 				case EMsg.ClientFSOfflineMessageNotification:
 					HandleFSOfflineMessageNotification(packetMsg);
 					break;
+				case EMsg.ClientItemAnnouncements:
+					HandleItemAnnouncements(packetMsg);
+					break;
 				case EMsg.ClientPurchaseResponse:
 					HandlePurchaseResponse(packetMsg);
 					break;
@@ -251,6 +277,15 @@ namespace ArchiSteamFarm {
 			Client.PostCallback(new OfflineMessageCallback(packetMsg.TargetJobID, response.Body));
 		}
 
+		private void HandleItemAnnouncements(IPacketMsg packetMsg) {
+			if (packetMsg == null) {
+				return;
+			}
+
+			var response = new ClientMsgProtobuf<CMsgClientItemAnnouncements>(packetMsg);
+			Client.PostCallback(new NotificationsCallback(packetMsg.TargetJobID, response.Body));
+		}
+
 		private void HandlePurchaseResponse(IPacketMsg packetMsg) {
 			if (packetMsg == null) {
 				return;

ArchiSteamFarm/ArchiSteamFarm.csproj

@@ -36,7 +36,7 @@
     <OutputPath>bin\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
+    <WarningLevel>3</WarningLevel>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -60,6 +60,16 @@
   <PropertyGroup>
     <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
   </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>false</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>
+    </AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DelaySign>false</DelaySign>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="HtmlAgilityPack, Version=1.4.9.0, Culture=neutral, PublicKeyToken=bd319b19eaf3b43a, processorArchitecture=MSIL">
       <HintPath>..\packages\HtmlAgilityPack.1.4.9\lib\Net45\HtmlAgilityPack.dll</HintPath>
@@ -91,6 +101,8 @@
     <Compile Include="ArchiHandler.cs" />
     <Compile Include="ArchiWebHandler.cs" />
     <Compile Include="Bot.cs" />
+    <Compile Include="BotConfig.cs" />
+    <Compile Include="BotDatabase.cs" />
     <Compile Include="CardsFarmer.cs" />
     <Compile Include="CMsgClientClanInviteAction.cs" />
     <Compile Include="Debugging.cs" />
@@ -108,6 +120,12 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="config\example.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="config\minimal.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
@@ -124,12 +142,6 @@
   </ItemGroup>
   <ItemGroup>
     <Content Include="cirno.ico" />
-    <Content Include="config\example.xml">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-    <Content Include="config\minimal.xml">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\SteamAuth\SteamAuth.csproj">
@@ -137,6 +149,7 @@
       <Name>SteamAuth</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PreBuildEvent>
@@ -145,15 +158,15 @@
   <PropertyGroup>
     <PostBuildEvent Condition=" '$(OS)' != 'Unix' AND '$(ConfigurationName)' == 'Release' ">
       mkdir "$(TargetDir)out" "$(TargetDir)out\config"
-      copy "$(TargetDir)config\example.xml" "$(TargetDir)out\config"
-      copy "$(TargetDir)config\minimal.xml" "$(TargetDir)out\config"
+      copy "$(TargetDir)config\example.json" "$(TargetDir)out\config"
+      copy "$(TargetDir)config\minimal.json" "$(TargetDir)out\config"
       "$(SolutionDir)tools\ILRepack.exe" /ndebug /internalize /parallel /targetplatform:v4 /wildcards /out:"$(TargetDir)out\ASF.exe" "$(TargetDir)$(TargetName).exe" "$(TargetDir)*.dll"
       del "$(TargetDir)out\ASF.exe.config"
     </PostBuildEvent>
     <PostBuildEvent Condition=" '$(OS)' == 'Unix' AND '$(ConfigurationName)' == 'Release' ">
       mkdir -p "$(TargetDir)out" "$(TargetDir)out/config"
-      cp "$(TargetDir)config/example.xml" "$(TargetDir)out/config"
-      cp "$(TargetDir)config/minimal.xml" "$(TargetDir)out/config"
+      cp "$(TargetDir)config/example.json" "$(TargetDir)out/config"
+      cp "$(TargetDir)config/minimal.json" "$(TargetDir)out/config"
       mono -O=all "$(SolutionDir)tools/ILRepack.exe" /ndebug /internalize /parallel /targetplatform:v4 /wildcards /out:"$(TargetDir)out/ASF.exe" "$(TargetDir)$(TargetName).exe" "$(TargetDir)*.dll"
       rm "$(TargetDir)out/ASF.exe.config"
     </PostBuildEvent>

ArchiSteamFarm/ArchiWebHandler.cs

@@ -37,17 +37,12 @@ namespace ArchiSteamFarm {
 		private const int Timeout = 1000 * WebBrowser.HttpTimeout; // In miliseconds
 
 		private readonly Bot Bot;
-		private readonly string ApiKey;
-		private readonly Dictionary<string, string> Cookie = new Dictionary<string, string>(3);
+		private readonly Dictionary<string, string> Cookie = new Dictionary<string, string>(4);
 
 		private ulong SteamID;
 
-		internal ArchiWebHandler(Bot bot, string apiKey) {
+		internal ArchiWebHandler(Bot bot) {
 			Bot = bot;
-
-			if (!string.IsNullOrEmpty(apiKey) && !apiKey.Equals("null")) {
-				ApiKey = apiKey;
-			}
 		}
 
 		internal async Task<bool> Init(SteamClient steamClient, string webAPIUserNonce, string parentalPin) {
@@ -109,6 +104,9 @@ namespace ArchiSteamFarm {
 			Cookie["steamLogin"] = steamLogin;
 			Cookie["steamLoginSecure"] = steamLoginSecure;
 
+			// The below is used for display purposes only
+			Cookie["webTradeEligibility"] = "{\"allowed\":0,\"reason\":0,\"allowed_at_time\":0,\"steamguard_required_days\":0,\"sales_this_year\":0,\"max_sales_per_year\":0,\"forms_requested\":0}";
+
 			await UnlockParentalAccount(parentalPin).ConfigureAwait(false);
 			return true;
 		}
@@ -144,12 +142,12 @@ namespace ArchiSteamFarm {
 		}
 
 		internal List<SteamTradeOffer> GetTradeOffers() {
-			if (ApiKey == null) {
+			if (string.IsNullOrEmpty(Bot.BotConfig.SteamApiKey)) {
 				return null;
 			}
 
 			KeyValue response = null;
-			using (dynamic iEconService = WebAPI.GetInterface("IEconService", ApiKey)) {
+			using (dynamic iEconService = WebAPI.GetInterface("IEconService", Bot.BotConfig.SteamApiKey)) {
 				iEconService.Timeout = Timeout;
 
 				for (byte i = 0; i < WebBrowser.MaxRetries && response == null; i++) {
@@ -266,12 +264,12 @@ namespace ArchiSteamFarm {
 		}
 
 		internal bool DeclineTradeOffer(ulong tradeID) {
-			if (tradeID == 0 || ApiKey == null) {
+			if (tradeID == 0 || string.IsNullOrEmpty(Bot.BotConfig.SteamApiKey)) {
 				return false;
 			}
 
 			KeyValue response = null;
-			using (dynamic iEconService = WebAPI.GetInterface("IEconService", ApiKey)) {
+			using (dynamic iEconService = WebAPI.GetInterface("IEconService", Bot.BotConfig.SteamApiKey)) {
 				iEconService.Timeout = Timeout;
 
 				for (byte i = 0; i < WebBrowser.MaxRetries && response == null; i++) {
@@ -419,6 +417,24 @@ namespace ArchiSteamFarm {
 			return htmlDocument;
 		}
 
+		internal async Task<bool> MarkInventory() {
+			if (SteamID == 0) {
+				return false;
+			}
+
+			HttpResponseMessage response = null;
+			for (byte i = 0; i < WebBrowser.MaxRetries && response == null; i++) {
+				response = await WebBrowser.UrlGet("https://steamcommunity.com/profiles/" + SteamID + "/inventory", Cookie).ConfigureAwait(false);
+			}
+
+			if (response == null) {
+				Logging.LogGenericWTF("Request failed even after " + WebBrowser.MaxRetries + " tries", Bot.BotName);
+				return false;
+			}
+
+			return true;
+		}
+
 		private async Task UnlockParentalAccount(string parentalPin) {
 			if (string.IsNullOrEmpty(parentalPin) || parentalPin.Equals("0")) {
 				return;

ArchiSteamFarm/Bot.cs

@@ -27,13 +27,11 @@ using SteamAuth;
 using SteamKit2;
 using SteamKit2.Internal;
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Security.Cryptography;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Xml;
 using System.Text;
 
 namespace ArchiSteamFarm {
@@ -41,17 +39,18 @@ namespace ArchiSteamFarm {
 		private const ulong ArchiSCFarmGroup = 103582791440160998;
 		private const ushort CallbackSleep = 500; // In miliseconds
 
-		internal static readonly ConcurrentDictionary<string, Bot> Bots = new ConcurrentDictionary<string, Bot>();
-		internal static readonly HashSet<uint> GlobalBlacklist = new HashSet<uint> { 303700, 335590, 368020, 425280 };
+		internal static readonly Dictionary<string, Bot> Bots = new Dictionary<string, Bot>();
 
 		private static readonly uint LoginID = MsgClientLogon.ObfuscationMask; // This must be the same for all ASF bots and all ASF processes
 
-		private readonly string ConfigFile, LoginKeyFile, MobileAuthenticatorFile, SentryFile;
+		private readonly string SentryFile;
 		private readonly Timer SendItemsTimer;
 
 		internal readonly string BotName;
 		internal readonly ArchiHandler ArchiHandler;
 		internal readonly ArchiWebHandler ArchiWebHandler;
+		internal readonly BotConfig BotConfig;
+		internal readonly BotDatabase BotDatabase;
 		internal readonly SteamClient SteamClient;
 
 		private readonly CallbackManager CallbackManager;
@@ -62,34 +61,10 @@ namespace ArchiSteamFarm {
 		private readonly Trading Trading;
 
 		internal bool KeepRunning { get; private set; } = false;
-		internal SteamGuardAccount SteamGuardAccount { get; private set; }
-
-		// Config variables
-		internal bool Enabled { get; private set; } = false;
-		internal string SteamLogin { get; private set; } = "null";
-		internal string SteamPassword { get; private set; } = "null";
-		internal string SteamNickname { get; private set; } = "null";
-		internal string SteamApiKey { get; private set; } = "null";
-		internal string SteamParentalPIN { get; private set; } = "0";
-		internal ulong SteamMasterID { get; private set; } = 0;
-		internal ulong SteamMasterClanID { get; private set; } = 0;
-		internal bool StartOnLaunch { get; private set; } = true;
-		internal bool CardDropsRestricted { get; private set; } = false;
-		internal bool FarmOffline { get; private set; } = false;
-		internal bool HandleOfflineMessages { get; private set; } = false;
-		internal bool ForwardKeysToOtherBots { get; private set; } = false;
-		internal bool DistributeKeys { get; private set; } = false;
-		internal bool UseAsfAsMobileAuthenticator { get; private set; } = false;
-		internal bool ShutdownOnFarmingFinished { get; private set; } = false;
-		internal bool SendOnFarmingFinished { get; private set; } = false;
-		internal string SteamTradeToken { get; private set; } = "null";
-		internal byte SendTradePeriod { get; private set; } = 0;
-		internal HashSet<uint> Blacklist { get; } = new HashSet<uint>();
-		internal bool Statistics { get; private set; } = true;
 
 		private bool InvalidPassword = false;
 		private bool LoggedInElsewhere = false;
-		private string AuthCode, LoginKey, TwoFactorAuth;
+		private string AuthCode, TwoFactorAuth;
 
 		internal static string GetAnyBotName() {
 			foreach (string botName in Bots.Keys) {
@@ -131,28 +106,78 @@ namespace ArchiSteamFarm {
 		}
 
 		internal Bot(string botName) {
-			if (Bots.ContainsKey(botName)) {
+			if (string.IsNullOrEmpty(botName)) {
 				return;
 			}
 
 			BotName = botName;
 
 			string botPath = Path.Combine(Program.ConfigDirectory, botName);
-			ConfigFile = botPath + ".xml";
-			LoginKeyFile = botPath + ".key";
-			MobileAuthenticatorFile = botPath + ".auth";
+
+			// CONVERSION START
+			if (File.Exists(botPath + ".xml")) {
+				BotConfig = BotConfig.LoadOldFormat(botPath + ".xml");
+				if (BotConfig == null) {
+					return;
+				}
+
+				if (BotConfig.Convert(botPath + ".json")) {
+					try {
+						File.Delete(botPath + ".xml");
+					} catch (Exception e) {
+						Logging.LogGenericException(e, botName);
+						return;
+					}
+				}
+			}
+			// CONVERSION END
+
+			BotConfig = BotConfig.Load(botPath + ".json");
+			if (BotConfig == null) {
+				Logging.LogGenericError("Your config for this bot instance is invalid, it won't run!", botName);
+				return;
+			}
+
+			// CONVERSION START
+			if (File.Exists(botPath + ".key")) {
+				BotDatabase = BotDatabase.Load(botPath + ".db");
+				try {
+					BotDatabase.LoginKey = File.ReadAllText(botPath + ".key");
+					File.Delete(botPath + ".key");
+				} catch (Exception e) {
+					Logging.LogGenericException(e, BotName);
+				}
+			}
+			if (File.Exists(botPath + ".auth")) {
+				BotDatabase = BotDatabase.Load(botPath + ".db");
+				try {
+					BotDatabase.SteamGuardAccount = JsonConvert.DeserializeObject<SteamGuardAccount>(File.ReadAllText(botPath + ".auth"));
+					File.Delete(botPath + ".auth");
+				} catch (Exception e) {
+					Logging.LogGenericException(e, BotName);
+				}
+			}
+			// CONVERSION END
+
+			if (!BotConfig.Enabled) {
+				return;
+			}
+
+			bool alreadyExists;
+			lock (Bots) {
+				alreadyExists = Bots.ContainsKey(botName);
+				if (!alreadyExists) {
+					Bots[botName] = this;
+				}
+			}
+
+			if (alreadyExists) {
+				return;
+			}
+
+			BotDatabase = BotDatabase.Load(botPath + ".db");
 			SentryFile = botPath + ".bin";
 
-			if (!ReadConfig()) {
-				return;
-			}
-
-			if (!Enabled) {
-				return;
-			}
-
-			Bots[botName] = this;
-
 			// Initialize
 			SteamClient = new SteamClient();
 
@@ -173,14 +198,6 @@ namespace ArchiSteamFarm {
 			CallbackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnFriendMsg);
 			CallbackManager.Subscribe<SteamFriends.FriendMsgHistoryCallback>(OnFriendMsgHistory);
 
-			if (UseAsfAsMobileAuthenticator && File.Exists(MobileAuthenticatorFile)) {
-				try {
-					SteamGuardAccount = JsonConvert.DeserializeObject<SteamGuardAccount>(File.ReadAllText(MobileAuthenticatorFile));
-				} catch (Exception e) {
-					Logging.LogGenericException(e, botName);
-				}
-			}
-
 			SteamUser = SteamClient.GetHandler<SteamUser>();
 			CallbackManager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo);
 			CallbackManager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff);
@@ -192,20 +209,20 @@ namespace ArchiSteamFarm {
 			CallbackManager.Subscribe<ArchiHandler.OfflineMessageCallback>(OnOfflineMessage);
 			CallbackManager.Subscribe<ArchiHandler.PurchaseResponseCallback>(OnPurchaseResponse);
 
-			ArchiWebHandler = new ArchiWebHandler(this, SteamApiKey);
+			ArchiWebHandler = new ArchiWebHandler(this);
 			CardsFarmer = new CardsFarmer(this);
 			Trading = new Trading(this);
 
-			if (SendTradePeriod > 0 && SendItemsTimer == null) {
+			if (BotConfig.SendTradePeriod > 0 && SendItemsTimer == null) {
 				SendItemsTimer = new Timer(
 					async e => await ResponseSendTrade().ConfigureAwait(false),
 					null,
-					TimeSpan.FromHours(SendTradePeriod), // Delay
-					TimeSpan.FromHours(SendTradePeriod) // Period
+					TimeSpan.FromHours(BotConfig.SendTradePeriod), // Delay
+					TimeSpan.FromHours(BotConfig.SendTradePeriod) // Period
 				);
 			}
 
-			if (!StartOnLaunch) {
+			if (!BotConfig.StartOnLaunch) {
 				return;
 			}
 
@@ -214,15 +231,15 @@ namespace ArchiSteamFarm {
 		}
 
 		internal async Task AcceptAllConfirmations() {
-			if (SteamGuardAccount == null) {
+			if (BotDatabase.SteamGuardAccount == null) {
 				return;
 			}
 
-			await SteamGuardAccount.RefreshSessionAsync().ConfigureAwait(false);
+			await BotDatabase.SteamGuardAccount.RefreshSessionAsync().ConfigureAwait(false);
 
 			try {
-				foreach (Confirmation confirmation in await SteamGuardAccount.FetchConfirmationsAsync().ConfigureAwait(false)) {
-					if (SteamGuardAccount.AcceptConfirmation(confirmation)) {
+				foreach (Confirmation confirmation in await BotDatabase.SteamGuardAccount.FetchConfirmationsAsync().ConfigureAwait(false)) {
+					if (BotDatabase.SteamGuardAccount.AcceptConfirmation(confirmation)) {
 						Logging.LogGenericInfo("Accepting confirmation: Success!", BotName);
 					} else {
 						Logging.LogGenericWarning("Accepting confirmation: Failed!", BotName);
@@ -235,6 +252,14 @@ namespace ArchiSteamFarm {
 			}
 		}
 
+		internal void ResetGamesPlayed() {
+			if (BotConfig.GamesPlayedWhileIdle.Contains(0)) {
+				ArchiHandler.PlayGames(0);
+			} else {
+				ArchiHandler.PlayGames(BotConfig.GamesPlayedWhileIdle);
+			}
+		}
+
 		internal async Task Restart() {
 			Stop();
 			await Utilities.SleepAsync(500).ConfigureAwait(false);
@@ -242,10 +267,10 @@ namespace ArchiSteamFarm {
 		}
 
 		internal async Task OnFarmingFinished(bool farmedSomething) {
-			if (farmedSomething && SendOnFarmingFinished) {
+			if (farmedSomething && BotConfig.SendOnFarmingFinished) {
 				await ResponseSendTrade().ConfigureAwait(false);
 			}
-			if (ShutdownOnFarmingFinished) {
+			if (BotConfig.ShutdownOnFarmingFinished) {
 				Shutdown();
 			}
 		}
@@ -398,15 +423,10 @@ namespace ArchiSteamFarm {
 		}
 
 		private async Task<string> ResponseSendTrade() {
-			if (SteamMasterID == 0) {
+			if (BotConfig.SteamMasterID == 0) {
 				return "Trade couldn't be send because SteamMasterID is not defined!";
 			}
 
-			string token = null;
-			if (!string.IsNullOrEmpty(SteamTradeToken) && !SteamTradeToken.Equals("null")) {
-				token = SteamTradeToken;
-			}
-
 			await Trading.LimitInventoryRequestsAsync().ConfigureAwait(false);
 			List<SteamItem> inventory = await ArchiWebHandler.GetMyTradableInventory().ConfigureAwait(false);
 
@@ -414,7 +434,7 @@ namespace ArchiSteamFarm {
 				return "Nothing to send, inventory seems empty!";
 			}
 
-			if (await ArchiWebHandler.SendTradeOffer(inventory, SteamMasterID, token).ConfigureAwait(false)) {
+			if (await ArchiWebHandler.SendTradeOffer(inventory, BotConfig.SteamMasterID, BotConfig.SteamTradeToken).ConfigureAwait(false)) {
 				await AcceptAllConfirmations().ConfigureAwait(false);
 				return "Trade offer sent successfully!";
 			} else {
@@ -436,12 +456,12 @@ namespace ArchiSteamFarm {
 		}
 
 		private string Response2FA() {
-			if (SteamGuardAccount == null) {
+			if (BotDatabase.SteamGuardAccount == null) {
 				return "That bot doesn't have ASF 2FA enabled!";
 			}
 
 			long timeLeft = 30 - TimeAligner.GetSteamTime() % 30;
-			return "2FA Token: " + SteamGuardAccount.GenerateSteamGuardCode() + " (expires in " + timeLeft + " seconds)";
+			return "2FA Token: " + BotDatabase.SteamGuardAccount.GenerateSteamGuardCode() + " (expires in " + timeLeft + " seconds)";
 		}
 
 		private static string Response2FA(string botName) {
@@ -458,7 +478,7 @@ namespace ArchiSteamFarm {
 		}
 
 		private string Response2FAOff() {
-			if (SteamGuardAccount == null) {
+			if (BotDatabase.SteamGuardAccount == null) {
 				return "That bot doesn't have ASF 2FA enabled!";
 			}
 
@@ -504,7 +524,7 @@ namespace ArchiSteamFarm {
 
 					ArchiHandler.PurchaseResponseCallback result;
 					try {
-						result = await currentBot.ArchiHandler.RedeemKey(key);
+						result = await currentBot.ArchiHandler.RedeemKey(key).ConfigureAwait(false);
 					} catch (Exception e) {
 						Logging.LogGenericException(e, currentBot.BotName);
 						break;
@@ -523,7 +543,7 @@ namespace ArchiSteamFarm {
 						case ArchiHandler.PurchaseResponseCallback.EPurchaseResult.OnCooldown:
 						case ArchiHandler.PurchaseResponseCallback.EPurchaseResult.RegionLocked:
 							response.Append(Environment.NewLine + "<" + currentBot.BotName + "> Key: " + key + " | Status: " + purchaseResult + " | Items: " + string.Join("", items));
-							if (DistributeKeys) {
+							if (BotConfig.DistributeKeys) {
 								do {
 									if (iterator.MoveNext()) {
 										currentBot = iterator.Current;
@@ -532,13 +552,13 @@ namespace ArchiSteamFarm {
 									}
 								} while (currentBot == this);
 
-								if (!ForwardKeysToOtherBots) {
+								if (!BotConfig.ForwardKeysToOtherBots) {
 									key = reader.ReadLine();
 								}
 								break;
 							}
 
-							if (!ForwardKeysToOtherBots) {
+							if (!BotConfig.ForwardKeysToOtherBots) {
 								key = reader.ReadLine();
 								break;
 							}
@@ -555,7 +575,7 @@ namespace ArchiSteamFarm {
 
 								ArchiHandler.PurchaseResponseCallback otherResult;
 								try {
-									otherResult = await bot.ArchiHandler.RedeemKey(key);
+									otherResult = await bot.ArchiHandler.RedeemKey(key).ConfigureAwait(false);
 								} catch (Exception e) {
 									Logging.LogGenericException(e, bot.BotName);
 									break; // We're done with this key
@@ -587,7 +607,7 @@ namespace ArchiSteamFarm {
 							break;
 						case ArchiHandler.PurchaseResponseCallback.EPurchaseResult.OK:
 							response.Append(Environment.NewLine + "<" + currentBot.BotName + "> Key: " + key + " | Status: " + purchaseResult + " | Items: " + string.Join("", items));
-							if (DistributeKeys) {
+							if (BotConfig.DistributeKeys) {
 								do {
 									if (iterator.MoveNext()) {
 										currentBot = iterator.Current;
@@ -601,7 +621,7 @@ namespace ArchiSteamFarm {
 						case ArchiHandler.PurchaseResponseCallback.EPurchaseResult.DuplicatedKey:
 						case ArchiHandler.PurchaseResponseCallback.EPurchaseResult.InvalidKey:
 							response.Append(Environment.NewLine + "<" + currentBot.BotName + "> Key: " + key + " | Status: " + purchaseResult + " | Items: " + string.Join("", items));
-							if (DistributeKeys && !ForwardKeysToOtherBots) {
+							if (BotConfig.DistributeKeys && !BotConfig.ForwardKeysToOtherBots) {
 								do {
 									if (iterator.MoveNext()) {
 										currentBot = iterator.Current;
@@ -700,7 +720,7 @@ namespace ArchiSteamFarm {
 
 			if (gameIDs.Contains(0)) {
 				if (await CardsFarmer.SwitchToManualMode(false).ConfigureAwait(false)) {
-					ArchiHandler.PlayGames(0);
+					ResetGamesPlayed();
 				}
 			} else {
 				await CardsFarmer.SwitchToManualMode(true).ConfigureAwait(false);
@@ -784,7 +804,7 @@ namespace ArchiSteamFarm {
 
 		private void HandleCallbacks() {
 			TimeSpan timeSpan = TimeSpan.FromMilliseconds(CallbackSleep);
-			while (KeepRunning) {
+			while (KeepRunning || SteamClient.IsConnected) {
 				CallbackManager.RunWaitCallbacks(timeSpan);
 			}
 		}
@@ -811,12 +831,12 @@ namespace ArchiSteamFarm {
 		}
 
 		private bool LinkMobileAuthenticator() {
-			if (SteamGuardAccount != null) {
+			if (BotDatabase.SteamGuardAccount != null) {
 				return false;
 			}
 
 			Logging.LogGenericInfo("Linking new ASF MobileAuthenticator...", BotName);
-			UserLogin userLogin = new UserLogin(SteamLogin, SteamPassword);
+			UserLogin userLogin = new UserLogin(BotConfig.SteamLogin, BotConfig.SteamPassword);
 			LoginResult loginResult;
 			while ((loginResult = userLogin.DoLogin()) != LoginResult.LoginOkay) {
 				switch (loginResult) {
@@ -843,14 +863,7 @@ namespace ArchiSteamFarm {
 				}
 			}
 
-			SteamGuardAccount = authenticatorLinker.LinkedAccount;
-
-			try {
-				File.WriteAllText(MobileAuthenticatorFile, JsonConvert.SerializeObject(SteamGuardAccount));
-			} catch (Exception e) {
-				Logging.LogGenericException(e, BotName);
-				return false;
-			}
+			BotDatabase.SteamGuardAccount = authenticatorLinker.LinkedAccount;
 
 			AuthenticatorLinker.FinalizeResult finalizeResult = authenticatorLinker.FinalizeAddAuthenticator(Program.GetUserInput(BotName, Program.EUserInputType.SMS));
 			if (finalizeResult != AuthenticatorLinker.FinalizeResult.Success) {
@@ -860,33 +873,30 @@ namespace ArchiSteamFarm {
 			}
 
 			Logging.LogGenericInfo("Successfully linked ASF as new mobile authenticator for this account!", BotName);
-			Program.GetUserInput(BotName, Program.EUserInputType.RevocationCode, SteamGuardAccount.RevocationCode);
+			Program.GetUserInput(BotName, Program.EUserInputType.RevocationCode, BotDatabase.SteamGuardAccount.RevocationCode);
 			return true;
 		}
 
 		private bool DelinkMobileAuthenticator() {
-			if (SteamGuardAccount == null) {
+			if (BotDatabase.SteamGuardAccount == null) {
 				return false;
 			}
 
-			bool result = SteamGuardAccount.DeactivateAuthenticator();
-			SteamGuardAccount = null;
+			bool result = BotDatabase.SteamGuardAccount.DeactivateAuthenticator();
 
-			try {
-				File.Delete(MobileAuthenticatorFile);
-			} catch (Exception e) {
-				Logging.LogGenericException(e, BotName);
+			if (result) {
+				BotDatabase.SteamGuardAccount = null;
 			}
 
 			return result;
 		}
 
 		private void JoinMasterChat() {
-			if (SteamMasterClanID == 0) {
+			if (BotConfig.SteamMasterClanID == 0) {
 				return;
 			}
 
-			SteamFriends.JoinChat(SteamMasterClanID);
+			SteamFriends.JoinChat(BotConfig.SteamMasterClanID);
 		}
 
 		private void OnConnected(SteamClient.ConnectedCallback callback) {
@@ -901,12 +911,10 @@ namespace ArchiSteamFarm {
 
 			Logging.LogGenericInfo("Connected to Steam!", BotName);
 
-			if (File.Exists(LoginKeyFile)) {
-				try {
-					LoginKey = File.ReadAllText(LoginKeyFile);
-				} catch (Exception e) {
-					Logging.LogGenericException(e, BotName);
-				}
+			if (!KeepRunning) {
+				Logging.LogGenericInfo("Disconnecting...", BotName);
+				SteamClient.Disconnect();
+				return;
 			}
 
 			byte[] sentryHash = null;
@@ -919,20 +927,20 @@ namespace ArchiSteamFarm {
 				}
 			}
 
-			if (SteamLogin.Equals("null")) {
-				SteamLogin = Program.GetUserInput(BotName, Program.EUserInputType.Login);
+			if (string.IsNullOrEmpty(BotConfig.SteamLogin)) {
+				BotConfig.SteamLogin = Program.GetUserInput(BotName, Program.EUserInputType.Login);
 			}
 
-			if (SteamPassword.Equals("null") && string.IsNullOrEmpty(LoginKey)) {
-				SteamPassword = Program.GetUserInput(BotName, Program.EUserInputType.Password);
+			if (string.IsNullOrEmpty(BotConfig.SteamPassword) && string.IsNullOrEmpty(BotDatabase.LoginKey)) {
+				BotConfig.SteamPassword = Program.GetUserInput(BotName, Program.EUserInputType.Password);
 			}
 
 			SteamUser.LogOn(new SteamUser.LogOnDetails {
-				Username = SteamLogin,
-				Password = SteamPassword,
+				Username = BotConfig.SteamLogin,
+				Password = BotConfig.SteamPassword,
 				AuthCode = AuthCode,
 				LoginID = LoginID,
-				LoginKey = LoginKey,
+				LoginKey = BotDatabase.LoginKey,
 				TwoFactorCode = TwoFactorAuth,
 				SentryFileHash = sentryHash,
 				ShouldRememberPassword = true
@@ -958,15 +966,8 @@ namespace ArchiSteamFarm {
 
 			if (InvalidPassword) {
 				InvalidPassword = false;
-				if (!string.IsNullOrEmpty(LoginKey)) { // InvalidPassword means usually that login key has expired, if we used it
-					LoginKey = null;
-
-					try {
-						File.Delete(LoginKeyFile);
-					} catch (Exception e) {
-						Logging.LogGenericException(e, BotName);
-					}
-
+				if (!string.IsNullOrEmpty(BotDatabase.LoginKey)) { // InvalidPassword means usually that login key has expired, if we used it
+					BotDatabase.LoginKey = null;
 					Logging.LogGenericInfo("Removed expired login key", BotName);
 				} else { // If we didn't use login key, InvalidPassword usually means we got captcha or other network-based throttling
 					Logging.LogGenericInfo("Will retry after 25 minutes...", BotName);
@@ -999,7 +1000,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.PatronID != SteamMasterID) {
+			if (callback.PatronID != BotConfig.SteamMasterID) {
 				return;
 			}
 
@@ -1015,7 +1016,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.ChatterID != SteamMasterID) {
+			if (callback.ChatterID != BotConfig.SteamMasterID) {
 				return;
 			}
 
@@ -1044,7 +1045,7 @@ namespace ArchiSteamFarm {
 						// TODO: Accept clan invites from master?
 						break;
 					default:
-						if (friend.SteamID == SteamMasterID) {
+						if (friend.SteamID == BotConfig.SteamMasterID) {
 							SteamFriends.AddFriend(friend.SteamID);
 						}
 						break;
@@ -1061,7 +1062,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.Sender != SteamMasterID) {
+			if (callback.Sender != BotConfig.SteamMasterID) {
 				return;
 			}
 
@@ -1077,7 +1078,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.SteamID != SteamMasterID) {
+			if (callback.SteamID != BotConfig.SteamMasterID) {
 				return;
 			}
 
@@ -1107,7 +1108,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (!FarmOffline) {
+			if (!BotConfig.FarmOffline) {
 				SteamFriends.SetPersonaState(EPersonaState.Online);
 			}
 		}
@@ -1135,13 +1136,13 @@ namespace ArchiSteamFarm {
 
 			switch (callback.Result) {
 				case EResult.AccountLogonDenied:
-					AuthCode = Program.GetUserInput(SteamLogin, Program.EUserInputType.SteamGuard);
+					AuthCode = Program.GetUserInput(BotConfig.SteamLogin, Program.EUserInputType.SteamGuard);
 					break;
 				case EResult.AccountLoginDeniedNeedTwoFactor:
-					if (SteamGuardAccount == null) {
-						TwoFactorAuth = Program.GetUserInput(SteamLogin, Program.EUserInputType.TwoFactorAuthentication);
+					if (BotDatabase.SteamGuardAccount == null) {
+						TwoFactorAuth = Program.GetUserInput(BotConfig.SteamLogin, Program.EUserInputType.TwoFactorAuthentication);
 					} else {
-						TwoFactorAuth = SteamGuardAccount.GenerateSteamGuardCode();
+						TwoFactorAuth = BotDatabase.SteamGuardAccount.GenerateSteamGuardCode();
 					}
 					break;
 				case EResult.InvalidPassword:
@@ -1151,7 +1152,7 @@ namespace ArchiSteamFarm {
 				case EResult.OK:
 					Logging.LogGenericInfo("Successfully logged on!", BotName);
 
-					if (UseAsfAsMobileAuthenticator && TwoFactorAuth == null && SteamGuardAccount == null) {
+					if (BotConfig.UseAsfAsMobileAuthenticator && TwoFactorAuth == null && BotDatabase.SteamGuardAccount == null) {
 						LinkMobileAuthenticator();
 					}
 
@@ -1159,25 +1160,23 @@ namespace ArchiSteamFarm {
 					AuthCode = null;
 					TwoFactorAuth = null;
 
-					if (!SteamNickname.Equals("null")) {
-						await SteamFriends.SetPersonaName(SteamNickname);
+					ResetGamesPlayed();
+
+					if (string.IsNullOrEmpty(BotConfig.SteamParentalPIN)) {
+						BotConfig.SteamParentalPIN = Program.GetUserInput(BotName, Program.EUserInputType.SteamParentalPIN);
 					}
 
-					if (SteamParentalPIN.Equals("null")) {
-						SteamParentalPIN = Program.GetUserInput(BotName, Program.EUserInputType.SteamParentalPIN);
-					}
-
-					if (!await ArchiWebHandler.Init(SteamClient, callback.WebAPIUserNonce, SteamParentalPIN).ConfigureAwait(false)) {
+					if (!await ArchiWebHandler.Init(SteamClient, callback.WebAPIUserNonce, BotConfig.SteamParentalPIN).ConfigureAwait(false)) {
 						await Restart().ConfigureAwait(false);
 						return;
 					}
 
-					if (SteamMasterClanID != 0) {
-						await ArchiWebHandler.JoinClan(SteamMasterClanID).ConfigureAwait(false);
+					if (BotConfig.SteamMasterClanID != 0) {
+						await ArchiWebHandler.JoinClan(BotConfig.SteamMasterClanID).ConfigureAwait(false);
 						JoinMasterChat();
 					}
 
-					if (Statistics) {
+					if (BotConfig.Statistics) {
 						await ArchiWebHandler.JoinClan(ArchiSCFarmGroup).ConfigureAwait(false);
 						SteamFriends.JoinChat(ArchiSCFarmGroup);
 					}
@@ -1204,12 +1203,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			try {
-				File.WriteAllText(LoginKeyFile, callback.LoginKey);
-			} catch (Exception e) {
-				Logging.LogGenericException(e, BotName);
-			}
-
+			BotDatabase.LoginKey = callback.LoginKey;
 			SteamUser.AcceptNewLoginKey(callback);
 		}
 
@@ -1250,14 +1244,18 @@ namespace ArchiSteamFarm {
 			}
 		}
 
-		private void OnNotifications(ArchiHandler.NotificationsCallback callback) {
-			if (callback == null) {
+		private async void OnNotifications(ArchiHandler.NotificationsCallback callback) {
+			if (callback == null || callback.Notifications == null) {
 				return;
 			}
 
 			bool checkTrades = false;
+			bool markInventory = false;
 			foreach (var notification in callback.Notifications) {
 				switch (notification.NotificationType) {
+					case ArchiHandler.NotificationsCallback.Notification.ENotificationType.Items:
+						markInventory = true;
+						break;
 					case ArchiHandler.NotificationsCallback.Notification.ENotificationType.Trading:
 						checkTrades = true;
 						break;
@@ -1267,6 +1265,10 @@ namespace ArchiSteamFarm {
 			if (checkTrades) {
 				Trading.CheckTrades();
 			}
+
+			if (markInventory && BotConfig.DismissInventoryNotifications) {
+				await ArchiWebHandler.MarkInventory().ConfigureAwait(false);
+			}
 		}
 
 		private void OnOfflineMessage(ArchiHandler.OfflineMessageCallback callback) {
@@ -1274,7 +1276,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (!HandleOfflineMessages) {
+			if (!BotConfig.HandleOfflineMessages) {
 				return;
 			}
 
@@ -1291,109 +1293,5 @@ namespace ArchiSteamFarm {
 				await CardsFarmer.RestartFarming().ConfigureAwait(false);
 			}
 		}
-
-		private bool ReadConfig() {
-			if (!File.Exists(ConfigFile)) {
-				return false;
-			}
-
-			try {
-				using (XmlReader reader = XmlReader.Create(ConfigFile)) {
-					while (reader.Read()) {
-						if (reader.NodeType != XmlNodeType.Element) {
-							continue;
-						}
-
-						string key = reader.Name;
-						if (string.IsNullOrEmpty(key)) {
-							continue;
-						}
-
-						string value = reader.GetAttribute("value");
-						if (string.IsNullOrEmpty(value)) {
-							continue;
-						}
-
-						switch (key) {
-							case "Enabled":
-								Enabled = bool.Parse(value);
-								break;
-							case "SteamLogin":
-								SteamLogin = value;
-								break;
-							case "SteamPassword":
-								SteamPassword = value;
-								break;
-							case "SteamNickname":
-								SteamNickname = value;
-								break;
-							case "SteamApiKey":
-								SteamApiKey = value;
-								break;
-							case "SteamTradeToken":
-								SteamTradeToken = value;
-								break;
-							case "SteamParentalPIN":
-								SteamParentalPIN = value;
-								break;
-							case "SteamMasterID":
-								SteamMasterID = ulong.Parse(value);
-								break;
-							case "SteamMasterClanID":
-								SteamMasterClanID = ulong.Parse(value);
-								break;
-							case "StartOnLaunch":
-								StartOnLaunch = bool.Parse(value);
-								break;
-							case "UseAsfAsMobileAuthenticator":
-								UseAsfAsMobileAuthenticator = bool.Parse(value);
-								break;
-							case "CardDropsRestricted":
-								CardDropsRestricted = bool.Parse(value);
-								break;
-							case "FarmOffline":
-								FarmOffline = bool.Parse(value);
-								break;
-							case "HandleOfflineMessages":
-								HandleOfflineMessages = bool.Parse(value);
-								break;
-							case "ForwardKeysToOtherBots":
-								ForwardKeysToOtherBots = bool.Parse(value);
-								break;
-							case "DistributeKeys":
-								DistributeKeys = bool.Parse(value);
-								break;
-							case "ShutdownOnFarmingFinished":
-								ShutdownOnFarmingFinished = bool.Parse(value);
-								break;
-							case "SendOnFarmingFinished":
-								SendOnFarmingFinished = bool.Parse(value);
-								break;
-							case "SendTradePeriod":
-								SendTradePeriod = byte.Parse(value);
-								break;
-							case "Blacklist":
-								Blacklist.Clear();
-								foreach (string appID in value.Split(',')) {
-									Blacklist.Add(uint.Parse(appID));
-								}
-								break;
-							case "Statistics":
-								Statistics = bool.Parse(value);
-								break;
-							default:
-								Logging.LogGenericWarning("Unrecognized config value: " + key + "=" + value, BotName);
-								break;
-						}
-					}
-				}
-			} catch (Exception e) {
-				Logging.LogGenericException(e, BotName);
-				Logging.LogGenericError("Your config for this bot instance is invalid, it won't run!", BotName);
-				return false;
-			}
-
-			return true;
-		}
 	}
 }

ArchiSteamFarm/BotConfig.cs

@@ -0,0 +1,259 @@
+/*
+    _                _      _  ____   _                           _____
+   / \    _ __  ___ | |__  (_)/ ___| | |_  ___   __ _  _ __ ___  |  ___|__ _  _ __  _ __ ___
+  / _ \  | '__|/ __|| '_ \ | |\___ \ | __|/ _ \ / _` || '_ ` _ \ | |_  / _` || '__|| '_ ` _ \
+ / ___ \ | |  | (__ | | | || | ___) || |_|  __/| (_| || | | | | ||  _|| (_| || |   | | | | | |
+/_/   \_\|_|   \___||_| |_||_||____/  \__|\___| \__,_||_| |_| |_||_|   \__,_||_|   |_| |_| |_|
+
+ Copyright 2015-2016 Łukasz "JustArchi" Domeradzki
+ Contact: JustArchi@JustArchi.net
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+					
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+*/
+
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Xml;
+
+namespace ArchiSteamFarm {
+	internal sealed class BotConfig {
+		internal static readonly HashSet<uint> GlobalBlacklist = new HashSet<uint> { 303700, 335590, 368020, 425280 };
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool Enabled { get; private set; } = false;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool StartOnLaunch { get; private set; } = true;
+
+		[JsonProperty]
+		internal string SteamLogin { get; set; } = null;
+
+		[JsonProperty]
+		internal string SteamPassword { get; set; } = null;
+
+		[JsonProperty]
+		internal string SteamParentalPIN { get; set; } = "0";
+
+		[JsonProperty]
+		internal string SteamApiKey { get; private set; } = null;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal ulong SteamMasterID { get; private set; } = 0;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal ulong SteamMasterClanID { get; private set; } = 0;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool CardDropsRestricted { get; private set; } = false;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool DismissInventoryNotifications { get; private set; } = true;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool FarmOffline { get; private set; } = false;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool HandleOfflineMessages { get; private set; } = false;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool ForwardKeysToOtherBots { get; private set; } = false;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool DistributeKeys { get; private set; } = false;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool UseAsfAsMobileAuthenticator { get; private set; } = false;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool ShutdownOnFarmingFinished { get; private set; } = false;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool SendOnFarmingFinished { get; private set; } = false;
+
+		[JsonProperty]
+		internal string SteamTradeToken { get; private set; } = null;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal byte SendTradePeriod { get; private set; } = 0;
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal HashSet<uint> GamesPlayedWhileIdle { get; private set; } = new HashSet<uint>() { 0 };
+
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool Statistics { get; private set; } = true;
+
+
+		internal static BotConfig Load(string path) {
+			if (!File.Exists(path)) {
+				return null;
+			}
+
+			BotConfig botConfig;
+			try {
+				botConfig = JsonConvert.DeserializeObject<BotConfig>(File.ReadAllText(path));
+			} catch (Exception e) {
+				Logging.LogGenericException(e);
+				return null;
+			}
+
+			return botConfig;
+		}
+
+		// TODO: This should be removed soon
+		internal static BotConfig LoadOldFormat(string path) {
+			if (!File.Exists(path)) {
+				return null;
+			}
+
+			BotConfig botConfig = new BotConfig();
+
+			try {
+				using (XmlReader reader = XmlReader.Create(path)) {
+					while (reader.Read()) {
+						if (reader.NodeType != XmlNodeType.Element) {
+							continue;
+						}
+
+						string key = reader.Name;
+						if (string.IsNullOrEmpty(key)) {
+							continue;
+						}
+
+						string value = reader.GetAttribute("value");
+						if (string.IsNullOrEmpty(value)) {
+							continue;
+						}
+
+						switch (key) {
+							case "Enabled":
+								botConfig.Enabled = bool.Parse(value);
+								break;
+							case "SteamLogin":
+								botConfig.SteamLogin = value;
+								break;
+							case "SteamPassword":
+								botConfig.SteamPassword = value;
+								break;
+							case "SteamApiKey":
+								botConfig.SteamApiKey = value;
+								break;
+							case "SteamTradeToken":
+								botConfig.SteamTradeToken = value;
+								break;
+							case "SteamParentalPIN":
+								botConfig.SteamParentalPIN = value;
+								break;
+							case "SteamMasterID":
+								botConfig.SteamMasterID = ulong.Parse(value);
+								break;
+							case "SteamMasterClanID":
+								botConfig.SteamMasterClanID = ulong.Parse(value);
+								break;
+							case "StartOnLaunch":
+								botConfig.StartOnLaunch = bool.Parse(value);
+								break;
+							case "UseAsfAsMobileAuthenticator":
+								botConfig.UseAsfAsMobileAuthenticator = bool.Parse(value);
+								break;
+							case "CardDropsRestricted":
+								botConfig.CardDropsRestricted = bool.Parse(value);
+								break;
+							case "FarmOffline":
+								botConfig.FarmOffline = bool.Parse(value);
+								break;
+							case "HandleOfflineMessages":
+								botConfig.HandleOfflineMessages = bool.Parse(value);
+								break;
+							case "ForwardKeysToOtherBots":
+								botConfig.ForwardKeysToOtherBots = bool.Parse(value);
+								break;
+							case "DistributeKeys":
+								botConfig.DistributeKeys = bool.Parse(value);
+								break;
+							case "ShutdownOnFarmingFinished":
+								botConfig.ShutdownOnFarmingFinished = bool.Parse(value);
+								break;
+							case "SendOnFarmingFinished":
+								botConfig.SendOnFarmingFinished = bool.Parse(value);
+								break;
+							case "SendTradePeriod":
+								botConfig.SendTradePeriod = byte.Parse(value);
+								break;
+							case "GamesPlayedWhileIdle":
+								botConfig.GamesPlayedWhileIdle.Clear();
+								foreach (string appID in value.Split(',')) {
+									botConfig.GamesPlayedWhileIdle.Add(uint.Parse(appID));
+								}
+								break;
+							case "Statistics":
+								botConfig.Statistics = bool.Parse(value);
+								break;
+							case "Blacklist":
+							case "SteamNickname":
+								break;
+							default:
+								Logging.LogGenericWarning("Unrecognized config value: " + key + "=" + value);
+								break;
+						}
+					}
+				}
+			} catch (Exception e) {
+				Logging.LogGenericException(e);
+				Logging.LogGenericError("Your config for this bot instance is invalid, it won't run!");
+				return null;
+			}
+
+			// Fixups for new format
+			if (botConfig.SteamLogin != null && botConfig.SteamLogin.Equals("null")) {
+				botConfig.SteamLogin = null;
+			}
+
+			if (botConfig.SteamPassword != null && botConfig.SteamPassword.Equals("null")) {
+				botConfig.SteamPassword = null;
+			}
+
+			if (botConfig.SteamApiKey != null && botConfig.SteamApiKey.Equals("null")) {
+				botConfig.SteamApiKey = null;
+			}
+
+			if (botConfig.SteamParentalPIN != null && botConfig.SteamParentalPIN.Equals("null")) {
+				botConfig.SteamParentalPIN = null;
+			}
+
+			if (botConfig.SteamTradeToken != null && botConfig.SteamTradeToken.Equals("null")) {
+				botConfig.SteamTradeToken = null;
+			}
+
+			return botConfig;
+		}
+
+		// This constructor is used only by deserializer
+		private BotConfig() { }
+
+		// TODO: This should be removed soon
+		internal bool Convert(string path) {
+			try {
+				File.WriteAllText(path, JsonConvert.SerializeObject(this, Newtonsoft.Json.Formatting.Indented));
+			} catch (Exception e) {
+				Logging.LogGenericException(e);
+				return false;
+			}
+
+			Logging.LogGenericWarning("Your config was converted to new ASF V2.0 format");
+			return true;
+		}
+	}
+}

ArchiSteamFarm/BotDatabase.cs

@@ -0,0 +1,96 @@
+/*
+    _                _      _  ____   _                           _____
+   / \    _ __  ___ | |__  (_)/ ___| | |_  ___   __ _  _ __ ___  |  ___|__ _  _ __  _ __ ___
+  / _ \  | '__|/ __|| '_ \ | |\___ \ | __|/ _ \ / _` || '_ ` _ \ | |_  / _` || '__|| '_ ` _ \
+ / ___ \ | |  | (__ | | | || | ___) || |_|  __/| (_| || | | | | ||  _|| (_| || |   | | | | | |
+/_/   \_\|_|   \___||_| |_||_||____/  \__|\___| \__,_||_| |_| |_||_|   \__,_||_|   |_| |_| |_|
+
+ Copyright 2015-2016 Łukasz "JustArchi" Domeradzki
+ Contact: JustArchi@JustArchi.net
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+					
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+*/
+
+using Newtonsoft.Json;
+using SteamAuth;
+using System;
+using System.IO;
+
+namespace ArchiSteamFarm {
+	internal sealed class BotDatabase {
+		internal string LoginKey {
+			get {
+				return _LoginKey;
+			}
+			set {
+				_LoginKey = value;
+				Save();
+			}
+		}
+
+		internal SteamGuardAccount SteamGuardAccount {
+			get {
+				return _SteamGuardAccount;
+			}
+			set {
+				_SteamGuardAccount = value;
+				Save();
+			}
+		}
+
+		[JsonProperty(Required = Required.AllowNull)]
+		private string _LoginKey;
+
+		[JsonProperty(Required = Required.AllowNull)]
+		private SteamGuardAccount _SteamGuardAccount;
+
+		private string FilePath;
+
+		internal static BotDatabase Load(string filePath) {
+			if (!File.Exists(filePath)) {
+				return new BotDatabase(filePath);
+			}
+
+			BotDatabase botDatabase;
+			try {
+				botDatabase = JsonConvert.DeserializeObject<BotDatabase>(File.ReadAllText(filePath));
+			} catch (Exception e) {
+				Logging.LogGenericException(e);
+				return null;
+			}
+
+			botDatabase.FilePath = filePath;
+			return botDatabase;
+		}
+
+		// This constructor is used when creating new database
+		private BotDatabase(string filePath) {
+			FilePath = filePath;
+			Save();
+		}
+
+		// This constructor is used only by deserializer
+		private BotDatabase() { }
+
+		private void Save() {
+			lock (FilePath) {
+				try {
+					File.WriteAllText(FilePath, JsonConvert.SerializeObject(this));
+				} catch (Exception e) {
+					Logging.LogGenericException(e);
+				}
+			}
+		}
+	}
+}

ArchiSteamFarm/CardsFarmer.cs

@@ -178,7 +178,7 @@ namespace ArchiSteamFarm {
 			bool farmedSomething = false;
 
 			// Now the algorithm used for farming depends on whether account is restricted or not
-			if (Bot.CardDropsRestricted) { // If we have restricted card drops, we use complex algorithm
+			if (Bot.BotConfig.CardDropsRestricted) { // If we have restricted card drops, we use complex algorithm
 				Logging.LogGenericInfo("Chosen farming algorithm: Complex", Bot.BotName);
 				while (GamesToFarm.Count > 0) {
 					List<uint> gamesToFarmSolo = GetGamesToFarmSolo(GamesToFarm);
@@ -294,7 +294,7 @@ namespace ArchiSteamFarm {
 			}
 
 			// If we have restricted card drops, actually do check hours of all games that are left to farm
-			if (Bot.CardDropsRestricted) {
+			if (Bot.BotConfig.CardDropsRestricted) {
 				tasks = new List<Task>(GamesToFarm.Keys.Count);
 				Logging.LogGenericInfo("Checking hours...", Bot.BotName);
 				foreach (uint appID in GamesToFarm.Keys) {
@@ -327,7 +327,7 @@ namespace ArchiSteamFarm {
 					continue;
 				}
 
-				if (Bot.GlobalBlacklist.Contains(appID) || Bot.Blacklist.Contains(appID)) {
+				if (BotConfig.GlobalBlacklist.Contains(appID)) {
 					continue;
 				}
 
@@ -426,7 +426,7 @@ namespace ArchiSteamFarm {
 				keepFarming = await ShouldFarm(appID).ConfigureAwait(false);
 			}
 
-			Bot.ArchiHandler.PlayGames(0);
+			Bot.ResetGamesPlayed();
 			Logging.LogGenericInfo("Stopped farming: " + appID, Bot.BotName);
 			return success;
 		}
@@ -459,7 +459,7 @@ namespace ArchiSteamFarm {
 				maxHour += timePlayed;
 			}
 
-			Bot.ArchiHandler.PlayGames(0);
+			Bot.ResetGamesPlayed();
 			Logging.LogGenericInfo("Stopped farming: " + string.Join(", ", appIDs), Bot.BotName);
 			return success;
 		}

ArchiSteamFarm/Program.cs

@@ -267,14 +267,25 @@ namespace ArchiSteamFarm {
 			// Before attempting to connect, initialize our list of CMs
 			Bot.RefreshCMs().Wait();
 
-			foreach (var configFile in Directory.EnumerateFiles(ConfigDirectory, "*.xml")) {
+			foreach (var configFile in Directory.EnumerateFiles(ConfigDirectory, "*.json")) {
 				string botName = Path.GetFileNameWithoutExtension(configFile);
 				Bot bot = new Bot(botName);
-				if (!bot.Enabled) {
+				if (!bot.BotConfig.Enabled) {
 					Logging.LogGenericInfo("Not starting this instance because it's disabled in config file", botName);
 				}
 			}
 
+			// CONVERSION START
+			foreach (var configFile in Directory.EnumerateFiles(ConfigDirectory, "*.xml")) {
+				string botName = Path.GetFileNameWithoutExtension(configFile);
+				Logging.LogGenericWarning("Found legacy " + botName + ".xml config file, it will now be converted to new ASF V2.0 format!");
+				Bot bot = new Bot(botName);
+				if (!bot.BotConfig.Enabled) {
+					Logging.LogGenericInfo("Not starting this instance because it's disabled in config file", botName);
+				}
+			}
+			// CONVERSION END
+
 			// Check if we got any bots running
 			OnBotShutdown();
 

ArchiSteamFarm/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.6.0.0")]
-[assembly: AssemblyFileVersion("1.6.0.0")]
+[assembly: AssemblyVersion("2.0.0.0")]
+[assembly: AssemblyFileVersion("2.0.0.0")]

ArchiSteamFarm/Trading.cs

@@ -88,7 +88,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (tradeOffer.items_to_give.Count == 0 || tradeOffer.OtherSteamID64 == Bot.SteamMasterID) {
+			if (tradeOffer.items_to_give.Count == 0 || tradeOffer.OtherSteamID64 == Bot.BotConfig.SteamMasterID) {
 				Logging.LogGenericInfo("Accepting trade: " + tradeID, Bot.BotName);
 				await Bot.ArchiWebHandler.AcceptTradeOffer(tradeID).ConfigureAwait(false);
 			} else {

ArchiSteamFarm/config/example.json

@@ -0,0 +1,25 @@
+{
+  "Enabled": false,
+  "StartOnLaunch": true,
+  "SteamLogin": null,
+  "SteamPassword": null,
+  "SteamParentalPIN": "0",
+  "SteamApiKey": null,
+  "SteamMasterID": 0,
+  "SteamMasterClanID": 0,
+  "CardDropsRestricted": false,
+  "DismissInventoryNotifications": true,
+  "FarmOffline": false,
+  "HandleOfflineMessages": false,
+  "ForwardKeysToOtherBots": false,
+  "DistributeKeys": false,
+  "UseAsfAsMobileAuthenticator": false,
+  "ShutdownOnFarmingFinished": false,
+  "SendOnFarmingFinished": false,
+  "SteamTradeToken": null,
+  "SendTradePeriod": 0,
+  "GamesPlayedWhileIdle": [
+    0
+  ],
+  "Statistics": true
+}

ArchiSteamFarm/config/example.xml

@@ -1,153 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<configuration>
-	<!-- This is full-fledged example config, you may be also interested in minimal.xml for bare minimum one -->
-
-	<!-- This config includes all user-switchable properties that you may want to change on per-bot basis -->
-	<!-- Default values used in config match default ASF values when given config property is not found -->
-	<!-- In other words, if given property is not defined, ASF will assume default pre-programmed value -->
-
-	<!-- Notice, if you use special characters reserved for XML, you should escape them -->
-	<!-- Escape table: [& - &amp;] | [" - &quot;] | [' - &apos;] | [< - &lt;] | [> - &gt;] -->
-	<!-- So e.g. if your SteamPassword is "foo&" you should write value="foo&amp;" -->
-
-	<!-- Type of the property is a tip for you that defines what values you can use -->
-	<!-- bool - Boolean value that can be only "true" or "false" -->
-	<!-- string - Any sequence of characters, unless stated otherwise (keep in mind escape table above), with special treatment of "null" value -->
-	<!-- byte - 8-bit unsigned integer, used mostly for small numbers (0-255) -->
-	<!-- uint - 32-bit unsigned integer, used mostly for steam appID -->
-	<!-- ulong - 64-bit unsigned (long) integer, used mostly for representing steamID64 -->
-	<!-- HashSet(uint) - Comma-separated list of unique 32-bit unsigned integers -->
-
-	<!-- Master switch to turn account on and off, set to "true" after you're done -->
-	<!-- This bot instance won't run unless below switch is set to "true" -->
-	<Enabled type="bool" value="false"/>
-
-	<!-- This is your steam login, the one you use for logging in to steam -->
-	<!-- You can use "null" if you wish to enter login on every startup -->
-	<SteamLogin type="string" value="null"/>
-
-	<!-- This is your steam password, the one you use for logging in to steam -->
-	<!-- You can use "null" if you wish to enter password on every startup -->
-	<SteamPassword type="string" value="null"/>
-
-	<!-- This is steam nickname, the one you want to use for bot. Can be anything up to 32 characters -->
-	<!-- You can use "null" if you wish to preserve your actual nickname, and this is what you want most likely -->
-	<SteamNickname type="string" value="null"/>
-
-	<!-- This is your bot's API key, get one at https://steamcommunity.com/dev/apikey while logged in as a bot, domain doesn't matter -->
-	<!-- Remember that each account should have unique API key generated through above link, wrong API key will make all API-based functionalities to fail -->
-	<!-- API key is useless for primary accounts, as they're not using trading feature, you can leave it at "null" if you're configuring a primary account -->
-	<!-- When at "null", it will disable all ASF API-based functionalities such as trading -->
-	<SteamApiKey type="string" value="null"/>
-
-	<!-- This is your parental PIN if you use steam parental functionality -->
-	<!-- Most likely you don't want to change it. You can use "null" if you wish to enter PIN on every startup, 0 means there is no PIN, and this is probably what you want -->
-	<SteamParentalPIN type="string" value="0"/>
-
-	<!-- This is steamID64 of the bot-master - you, for example "76561198006963719" -->
-	<!-- You can get one e.g. by logging in to http://steamrep.com/ -->
-	<!-- If you're configuring primary account, you can safely leave it at "0", as you're master yourself -->
-	<!-- When at "0", bot won't accept any commands, including steam cd-keys or trades" -->
-	<SteamMasterID type="ulong" value="0"/>
-
-	<!-- This is steamID64 of the master clan (group). If defined, bot will join the group and the chat automatically after logging in -->
-	<!-- The easiest way to get one is to check groups on your profile: http://steamcommunity.com/my/profile" -->
-	<!-- Then copying the URL of "Leave group" link, it will look like this: javascript:leaveGroupPrompt('103582791440160998','Archi\'s SC Farm') -->
-	<!-- The steamID64 we're looking for is there, in above example: "103582791440160998" -->
-	<!-- Remember that joining a group and the chat requires having non-restricted access to steam community, which is not always the case with alts -->
-	<!-- If you don't have your own farming group, most likely you don't want to change it, 0 means there is no master group defined -->
-	<SteamMasterClanID type="ulong" value="0"/>
-
-	<!-- This switch defines if bot should automatically start when ASF process is launched -->
-	<!-- Some people might want to avoid that, as they may prefer to issue "!start" command themselves -->
-	<!-- Most likely you want to keep this switch enabled, unless you have a reason -->
-	<StartOnLaunch type="bool" value="true"/>
-
-	<!-- This switch defines if you want to use built-in ASF two-factor-authentication (ASF 2FA) for this account -->
-	<!-- The one and only purpose for this function is automating steam logins and steam trades, so you won't need to enter 2FA codes all the time -->
-	<!-- This however defeats the whole purpose of two-factor-auth, and should be used on alt accounts ONLY -->
-	<!-- You should read full documentation, along with explanation here: https://github.com/JustArchi/ArchiSteamFarm/wiki/Escrow -->
-	<!-- Personally I suggest switching this to "true" ONLY for alts -->
-	<!-- WARNING, this option can potentially LOCK OUT YOUR ACCOUNT! If you don't fully understand this feature, DON'T USE IT! -->
-	<UseAsfAsMobileAuthenticator type="bool" value="false"/>
-
-	<!-- This switch defines if the account has card drops restricted -->
-	<!-- Restricted card drops means that the account doesn't receive any steam cards until it plays the game for at least 2 hours -->
-	<!-- There is no magical way to detect it by ASF, I made this option config-based switch -->
-	<!-- Based on our observations, it looks like most accounts that never issued a refund have non-restricted card drops, and this is what default value assumes -->
-	<!-- However, if you noticed that your cards never drop until you hit 2 hours played mark, consider setting it as "true" -->
-	<!-- Guessing "wrong" won't have any real consequences, ASF will just work in non-optimal way, and everybody wants to drop cards fast, right? -->
-	<!-- Based on this parameter, ASF will try to choose the most optimal cards farming algorithm for this account -->
-	<CardDropsRestricted type="bool" value="false"/>
-
-	<!-- This switch defines if the account should stay as "Offline" after logging in to Steam. This has several advantages and disadvantages -->
-	<!-- Personally I find it extremely useful for primary accounts, as your status will remain "Online" and not "In-Game" when ASF is farming -->
-	<!-- Thanks to that, your friends will never ask you again if you're playing or farming the game. Your status will now nicely reflect that -->
-	<!-- However, it's less useful for alt accounts, as you won't be able to interact with bots and check what they're doing - they'll appear as "Offline" -->
-	<!-- Personally I suggest switching this to "true" for primary accounts, and leaving it at "false" for alt accounts -->
-	<!-- Bot won't be able to receive and answer to your commands, unless you set "HandleOfflineMessages" below to "true" as well -->
-	<FarmOffline type="bool" value="false"/>
-
-	<!-- This switch defines if bot should handle offline messages when it sees them -->
-	<!-- Basically it should be used only when "FarmOffline" property above is true, so bot can handle offline messages -->
-	<!-- Reading offline messages will also mark them as received, therefore it should not be used if you want to keep them for later -->
-	<!-- Personally I suggest keeping this on "false" for primary accounts, and considering switching to "true" for alts, if "FarmOffline" above is set to true as well -->
-	<HandleOfflineMessages type="bool" value="false"/>
-
-	<!-- This switch defines if bot should try to forward key to the other bot in case of failing to redeem on his own account -->
-	<!-- This can be useful if you want to send key to your farm and you don't care which account redeems it -->
-	<!-- When "true", bot will try redeeming "AlreadyOwned", "BaseGameRequired", "OnCooldown" and "RegionLocked" keys on other available accounts -->
-	<!-- By default this option is disabled, as not everyone might want to redeem keys on other configured accounts -->
-	<!-- WARNING: Remember that Steam issues temporary ban on too many failed key activations (OnCooldown status) -->
-	<!-- Therefore, be careful when it comes to multiple keys activations, this option is supposed to help you, not make you lazy -->
-	<ForwardKeysToOtherBots type="bool" value="false"/>
-
-	<!-- This switch defines bot's behaviour on getting multiple keys -->
-	<!-- When "false", bot will try to redeem all keys on it's own account, when "true", keys will be distributed on "one bot, one key" basis -->
-	<!-- Keep in mind that "ForwardKeysToOtherBots" property defined above affects this switch as well -->
-	<!-- When "ForwardKeysToOtherBots" is "true", bot will try redeeming "AlreadyOwned", "BaseGameRequired", "OnCooldown" and "RegionLocked" keys on other available accounts -->
-	<!-- If "ForwardKeysToOtherBots" is set to "false", bot will keep unused keys for itself -->
-	<!-- By default this option is disabled, as not everyone might want to alter the multiple keys redeeming behaviour -->
-	<!-- Switch this to "true" only if you prefer to use "one bot, one key" behaviour, instead of default one, which is to redeem all keys only on one account -->
-	<DistributeKeys type="bool" value="false"/>
-
-	<!-- This switch defines if bot should disconnect once farming is finished -->
-	<!-- Keep in mind that when no bots are active, ASF will shutdown as well -->
-	<!-- You may want to disconnect the bot after he's done, if that's the case, set below to "true" -->
-	<!-- However, you may instead want to keep it online for the whole time, in this case, leave it at "false" -->
-	<!-- Even when bot is not farming anything, he'll keep checking badges from time to time, if there is anything new to farm -->
-	<!-- Personally I suggest leaving it at "false", unless you have a reason to close the process after all bots finished farming -->
-	<ShutdownOnFarmingFinished type="bool" value="false"/>
-
-	<!-- This switch defines if bot should send you all the items it farmed after farming is finished -->
-	<!-- Remember that in order to use this feature, SteamMasterID must be defined above -->
-	<!-- If SteamMasterID is not a friend of this bot, SteamTradeToken will also be needed to set below -->
-	<SendOnFarmingFinished type="bool" value="false"/>
-
-	<!-- This is a SteamTradeToken of SteamMasterID, which is required if bot doesn't have SteamMasterID on friend list -->
-	<!-- You can get the token here: http://steamcommunity.com/id/me/tradeoffers/privacy while being logged in as SteamMasterID -->
-	<!-- The token has 8 characters and is written in the last part of trade URL link, starting after "&token=" -->
-	<SteamTradeToken type="string" value="null"/>
-
-	<!-- This switch defines if bot should send you trade offer with all farmed cards on regular basis -->
-	<!-- This can become useful if you have lots of games to farm and you don't want to wait for all of them to be farmed -->
-	<!-- However, if you have many bots running, it may become a bit spammy/intrusive, so it's not enabled by default -->
-	<!-- Remember that there is also "SendOnFarmingFinished" switch above, which is far less intrusive and can be used instead -->
-	<!-- This property defines how often bot should send you a trade offer, in hours -->
-	<!-- For example, setting this to "24" will result in a trade offer being sent once per day (24 hours) -->
-	<!-- Default value of "0" disables that feature -->
-	<SendTradePeriod type="byte" value="0"/>
-
-	<!-- This is comma-separated list of IDs that should not be considered for farming -->
-	<!-- Default value includes appIDs that are wrongly appearing on the profile, e.g. Summer Sale, Winter Sale or Monster Summer Game -->
-	<!-- In addition to blacklist defined here, ASF also has global blacklist, which is being updated on as-needed basis, so you don't need to update this entry -->
-	<!-- You probably don't want to change anything here -->
-	<Blacklist type="HashSet(uint)" value="303700,335590,368020,425280"/>
-
-	<!-- This switch enables statistics for me - bot will join Archi's SC Farm group and chat on steam -->
-	<!-- Consider leaving it at "true", this way I can check how many running bots are active -->
-	<!-- Such information directly affects my willings to work on the project, as I can see how many users are actually using it -->
-	<!-- So if you want to see new versions coming up, bugs being fixed, and new features getting implemented, consider leaving it at "true" -->
-	<!-- You can find the group, along with all the statistics here: http://steamcommunity.com/groups/ascfarm -->
-	<Statistics type="bool" value="true"/>
-</configuration>

ArchiSteamFarm/config/minimal.json

@@ -0,0 +1,5 @@
+{
+  "Enabled": false,
+  "SteamLogin": null,
+  "SteamPassword": null
+}

ArchiSteamFarm/config/minimal.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<configuration>
-	<!-- This is minimalistic config "just to make ASF work". For full-fledged config, please take a look at example.xml -->
-	<!-- Full-fledged config includes some neat features such as offline farming or cards farming algorithm selection -->
-	<!-- ASF will use default values for missing properties, check example.xml to see all of them -->
-	<Enabled type="bool" value="false"/>
-	<SteamLogin type="string" value="null"/>
-	<SteamPassword type="string" value="null"/>
-</configuration>

README.md

@@ -1,6 +1,10 @@
 ArchiSteamFarm
 ===================
 
+[![Build status](https://ci.appveyor.com/api/projects/status/yi0y25nipcb1j1yj?svg=true)](https://ci.appveyor.com/project/JustArchi/archisteamfarm) [![GitHub release](https://img.shields.io/github/release/JustArchi/ArchiSteamFarm.svg)](https://github.com/JustArchi/ArchiSteamFarm/releases/latest) [![Github All Releases](https://img.shields.io/github/downloads/JustArchi/ArchiSteamFarm/total.svg)](https://github.com/JustArchi/ArchiSteamFarm/releases) [![Paypal donate](https://img.shields.io/badge/paypal-donate-yellow.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=HD2P2P3WGS5Y4) [![Steam donate](https://img.shields.io/badge/steam-donate-yellow.svg)](https://steamcommunity.com/tradeoffer/new/?partner=46697991&token=0ix2Ruv_)
+
+---
+
 ASF is a C# application that allows you to farm steam cards using multiple steam accounts simultaneously. Unlike idle master which works only on one account at given time, requires steam client running in background, and launches additional processes imitiating "game playing" status, ASF doesn't require any steam client running in the background, doesn't launch any additional processes and is made to handle unlimited steam accounts at once. In addition to that, it's meant to be run on servers or other desktop-less machines, and features full Mono support, which makes it possible to launch on any Mono-supported operating system, such as Windows, Linux or OS X. ASF is based on, and possible, thanks to [SteamKit2](https://github.com/SteamRE/SteamKit).
 
 ASF doesn't require and doesn't interfere in any way with Steam client. In addition to that, it no longer requires exclusive access to given account, which means that you can use your main account in Steam client, and use ASF for farming the same account at the same time. If you decide to launch a game, ASF will get disconnected, and resume farming once you finish playing your game, being as transparent as possible.