cleanup

# Conflicts:
#	Tests/CodexTests/UtilityTests/DiscordBotTests.cs

ProjectPlugins/CodexDiscordBotPlugin/CodexDiscordBotPlugin.cs

@@ -1,11 +1,13 @@
 using Core;
 using KubernetesWorkflow;
 using KubernetesWorkflow.Types;
+using Utils;
 
 namespace CodexDiscordBotPlugin
 {
     public class CodexDiscordBotPlugin : IProjectPlugin, IHasLogPrefix, IHasMetadata
     {
+        private const string ExpectedStartupMessage = "Debug option is set. Discord connection disabled!";
         private readonly IPluginTools tools;
 
         public CodexDiscordBotPlugin(IPluginTools tools)
@@ -46,14 +48,56 @@ namespace CodexDiscordBotPlugin
             var startupConfig = new StartupConfig();
             startupConfig.NameOverride = config.Name;
             startupConfig.Add(config);
-            return workflow.Start(1, new DiscordBotContainerRecipe(), startupConfig).WaitForOnline();
+            var pod = workflow.Start(1, new DiscordBotContainerRecipe(), startupConfig).WaitForOnline();
+            WaitForStartupMessage(workflow, pod);
+            return pod;
         }
 
         private RunningPod StartRewarderContainer(IStartupWorkflow workflow, RewarderBotStartupConfig config)
         {
             var startupConfig = new StartupConfig();
+            startupConfig.NameOverride = config.Name;
             startupConfig.Add(config);
             return workflow.Start(1, new RewarderBotContainerRecipe(), startupConfig).WaitForOnline();
         }
+
+        private void WaitForStartupMessage(IStartupWorkflow workflow, RunningPod pod)
+        {
+            var finder = new LogLineFinder(ExpectedStartupMessage, workflow);
+            Time.WaitUntil(() =>
+            {
+                finder.FindLine(pod);
+                return finder.Found;
+            }, nameof(WaitForStartupMessage));
+        }
+
+        public class LogLineFinder : LogHandler
+        {
+            private readonly string message;
+            private readonly IStartupWorkflow workflow;
+
+            public LogLineFinder(string message, IStartupWorkflow workflow)
+            {
+                this.message = message;
+                this.workflow = workflow;
+            }
+
+            public void FindLine(RunningPod pod)
+            {
+                Found = false;
+                foreach (var c in pod.Containers)
+                {
+                    workflow.DownloadContainerLog(c, this);
+                    if (Found) return;
+                }
+            }
+
+            public bool Found { get; private set; }
+
+            protected override void ProcessLine(string line)
+            {
+                if (!Found && line.Contains(message)) Found = true;
+            }
+        }
     }
 }

ProjectPlugins/CodexDiscordBotPlugin/DiscordBotContainerRecipe.cs

@@ -7,7 +7,7 @@ namespace CodexDiscordBotPlugin
     public class DiscordBotContainerRecipe : ContainerRecipeFactory
     {
         public override string AppName => "discordbot-bibliotech";
-        public override string Image => "codexstorage/codex-discordbot:sha-8c64352";
+        public override string Image => "codexstorage/codex-discordbot:sha-22cf82b";
 
         public static string RewardsPort = "bot_rewards_port";
 
@@ -33,6 +33,8 @@ namespace CodexDiscordBotPlugin
             AddEnvVar("CODEXCONTRACTS_TOKENADDRESS", gethInfo.TokenAddress);
             AddEnvVar("CODEXCONTRACTS_ABI", gethInfo.Abi);
 
+            AddEnvVar("NODISCORD", "1");
+
             AddInternalPortAndVar("REWARDAPIPORT", RewardsPort);
 
             if (!string.IsNullOrEmpty(config.DataPath))

ProjectPlugins/CodexDiscordBotPlugin/DiscordBotStartupConfig.cs

@@ -27,8 +27,9 @@
 
     public class RewarderBotStartupConfig
     {
-        public RewarderBotStartupConfig(string discordBotHost, int discordBotPort, string intervalMinutes, DateTime historyStartUtc, DiscordBotGethInfo gethInfo, string? dataPath)
+        public RewarderBotStartupConfig(string name, string discordBotHost, int discordBotPort, int intervalMinutes, DateTime historyStartUtc, DiscordBotGethInfo gethInfo, string? dataPath)
         {
+            Name = name;
             DiscordBotHost = discordBotHost;
             DiscordBotPort = discordBotPort;
             IntervalMinutes = intervalMinutes;
@@ -37,9 +38,10 @@
             DataPath = dataPath;
         }
 
+        public string Name { get; }
         public string DiscordBotHost { get; }
         public int DiscordBotPort { get; }
-        public string IntervalMinutes { get; }
+        public int IntervalMinutes { get; }
         public DateTime HistoryStartUtc { get; }
         public DiscordBotGethInfo GethInfo { get; }
         public string? DataPath { get; set; }

ProjectPlugins/CodexDiscordBotPlugin/RewarderBotContainerRecipe.cs

@@ -7,7 +7,7 @@ namespace CodexDiscordBotPlugin
     public class RewarderBotContainerRecipe : ContainerRecipeFactory
     {
         public override string AppName => "discordbot-rewarder";
-        public override string Image => "codexstorage/codex-rewarderbot:sha-2ab84e2";
+        public override string Image => "codexstorage/codex-rewarderbot:sha-12dc7ef";
 
         protected override void Initialize(StartupConfig startupConfig)
         {
@@ -17,7 +17,7 @@ namespace CodexDiscordBotPlugin
 
             AddEnvVar("DISCORDBOTHOST", config.DiscordBotHost);
             AddEnvVar("DISCORDBOTPORT", config.DiscordBotPort.ToString());
-            AddEnvVar("INTERVALMINUTES", config.IntervalMinutes);
+            AddEnvVar("INTERVALMINUTES", config.IntervalMinutes.ToString());
             var offset = new DateTimeOffset(config.HistoryStartUtc);
             AddEnvVar("CHECKHISTORY", offset.ToUnixTimeSeconds().ToString());
 

ProjectPlugins/CodexPlugin/CodexContainerRecipe.cs

@@ -109,8 +109,9 @@ namespace CodexPlugin
 
                 // Custom scripting in the Codex test image will write this variable to a private-key file,
                 // and pass the correct filename to Codex.
-                AddEnvVar("PRIV_KEY", marketplaceSetup.EthAccount.PrivateKey);
-                Additional(marketplaceSetup.EthAccount);
+                var account = marketplaceSetup.EthAccountSetup.GetNew();
+                AddEnvVar("PRIV_KEY", account.PrivateKey);
+                Additional(account);
 
                 SetCommandOverride(marketplaceSetup);
                 if (marketplaceSetup.IsValidator)

ProjectPlugins/CodexPlugin/CodexNode.cs

@@ -23,6 +23,7 @@ namespace CodexPlugin
         CrashWatcher CrashWatcher { get; }
         PodInfo GetPodInfo();
         ITransferSpeeds TransferSpeeds { get; }
+        EthAccount EthAccount { get; }
         void Stop(bool waitTillStopped);
     }
 
@@ -30,13 +31,13 @@ namespace CodexPlugin
     {
         private const string UploadFailedMessage = "Unable to store block";
         private readonly IPluginTools tools;
-        private readonly EthAddress? ethAddress;
+        private readonly EthAccount? ethAccount;
         private readonly TransferSpeeds transferSpeeds;
 
-        public CodexNode(IPluginTools tools, CodexAccess codexAccess, CodexNodeGroup group, IMarketplaceAccess marketplaceAccess, EthAddress? ethAddress)
+        public CodexNode(IPluginTools tools, CodexAccess codexAccess, CodexNodeGroup group, IMarketplaceAccess marketplaceAccess, EthAccount? ethAccount)
         {
             this.tools = tools;
-            this.ethAddress = ethAddress;
+            this.ethAccount = ethAccount;
             CodexAccess = codexAccess;
             Group = group;
             Marketplace = marketplaceAccess;
@@ -66,8 +67,17 @@ namespace CodexPlugin
         {
             get
             {
-                if (ethAddress == null) throw new Exception("Marketplace is not enabled for this Codex node. Please start it with the option '.EnableMarketplace(...)' to enable it.");
-                return ethAddress;
+                EnsureMarketplace();
+                return ethAccount!.EthAddress;
+            }
+        }
+
+        public EthAccount EthAccount
+        {
+            get
+            {
+                EnsureMarketplace();
+                return ethAccount!;
             }
         }
 
@@ -197,6 +207,11 @@ namespace CodexPlugin
             }
         }
 
+        private void EnsureMarketplace()
+        {
+            if (ethAccount == null) throw new Exception("Marketplace is not enabled for this Codex node. Please start it with the option '.EnableMarketplace(...)' to enable it.");
+        }
+
         private void Log(string msg)
         {
             tools.GetLog().Log($"{GetName()}: {msg}");

ProjectPlugins/CodexPlugin/CodexNodeFactory.cs

@@ -22,22 +22,22 @@ namespace CodexPlugin
 
         public CodexNode CreateOnlineCodexNode(CodexAccess access, CodexNodeGroup group)
         {
-            var ethAddress = GetEthAddress(access);
-            var marketplaceAccess = GetMarketplaceAccess(access, ethAddress);
-            return new CodexNode(tools, access, group, marketplaceAccess, ethAddress);
+            var ethAccount = GetEthAccount(access);
+            var marketplaceAccess = GetMarketplaceAccess(access, ethAccount);
+            return new CodexNode(tools, access, group, marketplaceAccess, ethAccount);
         }
 
-        private IMarketplaceAccess GetMarketplaceAccess(CodexAccess codexAccess, EthAddress? ethAddress)
+        private IMarketplaceAccess GetMarketplaceAccess(CodexAccess codexAccess, EthAccount? ethAccount)
         {
-            if (ethAddress == null) return new MarketplaceUnavailable();
+            if (ethAccount == null) return new MarketplaceUnavailable();
             return new MarketplaceAccess(tools.GetLog(), codexAccess);
         }
 
-        private EthAddress? GetEthAddress(CodexAccess access)
+        private EthAccount? GetEthAccount(CodexAccess access)
         {
             var ethAccount = access.Container.Containers.Single().Recipe.Additionals.Get<EthAccount>();
             if (ethAccount == null) return null;
-            return ethAccount.EthAddress;
+            return ethAccount;
         }
 
         public CrashWatcher CreateCrashWatcher(RunningContainer c)

ProjectPlugins/CodexPlugin/CodexSetup.cs

@@ -169,7 +169,7 @@ namespace CodexPlugin
         public bool IsValidator { get; private set; }
         public Ether InitialEth { get; private set; } = 0.Eth();
         public TestToken InitialTestTokens { get; private set; } = 0.Tst();
-        public EthAccount EthAccount { get; private set; } = EthAccount.GenerateNew();
+        public EthAccountSetup EthAccountSetup { get; private set; } = new EthAccountSetup();
 
         public IMarketplaceSetup AsStorageNode()
         {
@@ -185,7 +185,7 @@ namespace CodexPlugin
 
         public IMarketplaceSetup WithAccount(EthAccount account)
         {
-            EthAccount = account;
+            EthAccountSetup.Pin(account);
             return this;
         }
 
@@ -201,10 +201,41 @@ namespace CodexPlugin
             var result = "[(clientNode)"; // When marketplace is enabled, being a clientNode is implicit.
             result += IsStorageNode ? "(storageNode)" : "()";
             result += IsValidator ? "(validator)" : "() ";
-            result += $"Address: '{EthAccount.EthAddress}' ";
+            result += $"Address: '{EthAccountSetup}' ";
             result += $"{InitialEth.Eth} / {InitialTestTokens}";
             result += "] ";
             return result;
         }
     }
+
+    public class EthAccountSetup
+    {
+        private readonly List<EthAccount> accounts = new List<EthAccount>();
+        private bool pinned = false;
+
+        public void Pin(EthAccount account)
+        {
+            accounts.Add(account);
+            pinned = true;
+        }
+
+        public EthAccount GetNew()
+        {
+            if (pinned) return accounts.Last();
+
+            var a = EthAccount.GenerateNew();
+            accounts.Add(a);
+            return a;
+        }
+
+        public EthAccount[] GetAll()
+        {
+            return accounts.ToArray();
+        }
+
+        public override string ToString()
+        {
+            return string.Join(",", accounts.Select(a => a.ToString()).ToArray());
+        }
+    }
 }

ProjectPlugins/CodexPlugin/MarketplaceAccess.cs

@@ -1,5 +1,4 @@
 using Logging;
-using Newtonsoft.Json;
 using Utils;
 
 namespace CodexPlugin
@@ -7,7 +6,7 @@ namespace CodexPlugin
     public interface IMarketplaceAccess
     {
         string MakeStorageAvailable(StorageAvailability availability);
-        StoragePurchaseContract RequestStorage(StoragePurchaseRequest purchase);
+        IStoragePurchaseContract RequestStorage(StoragePurchaseRequest purchase);
     }
 
     public class MarketplaceAccess : IMarketplaceAccess
@@ -21,7 +20,7 @@ namespace CodexPlugin
             this.codexAccess = codexAccess;
         }
 
-        public StoragePurchaseContract RequestStorage(StoragePurchaseRequest purchase)
+        public IStoragePurchaseContract RequestStorage(StoragePurchaseRequest purchase)
         {
             purchase.Log(log);
 
@@ -68,7 +67,7 @@ namespace CodexPlugin
             throw new NotImplementedException();
         }
 
-        public StoragePurchaseContract RequestStorage(StoragePurchaseRequest purchase)
+        public IStoragePurchaseContract RequestStorage(StoragePurchaseRequest purchase)
         {
             Unavailable();
             throw new NotImplementedException();
@@ -80,131 +79,4 @@ namespace CodexPlugin
             throw new InvalidOperationException();
         }
     }
-
-    public class StoragePurchaseContract
-    {
-        private readonly ILog log;
-        private readonly CodexAccess codexAccess;
-        private readonly TimeSpan gracePeriod = TimeSpan.FromSeconds(30);
-        private readonly DateTime contractPendingUtc = DateTime.UtcNow;
-        private DateTime? contractSubmittedUtc = DateTime.UtcNow;
-        private DateTime? contractStartedUtc;
-        private DateTime? contractFinishedUtc;
-
-        public StoragePurchaseContract(ILog log, CodexAccess codexAccess, string purchaseId, StoragePurchaseRequest purchase)
-        {
-            this.log = log;
-            this.codexAccess = codexAccess;
-            PurchaseId = purchaseId;
-            Purchase = purchase;
-        }
-
-        public string PurchaseId { get; }
-        public StoragePurchaseRequest Purchase { get; }
-
-        public TimeSpan? PendingToSubmitted => contractSubmittedUtc - contractPendingUtc;
-        public TimeSpan? SubmittedToStarted => contractStartedUtc - contractSubmittedUtc;
-        public TimeSpan? SubmittedToFinished => contractFinishedUtc - contractSubmittedUtc;
-
-        public void WaitForStorageContractSubmitted()
-        {
-            WaitForStorageContractState(gracePeriod, "submitted", sleep: 200);
-            contractSubmittedUtc = DateTime.UtcNow;
-            LogSubmittedDuration();
-            AssertDuration(PendingToSubmitted, gracePeriod, nameof(PendingToSubmitted));
-        }
-
-        public void WaitForStorageContractStarted()
-        {
-            var timeout = Purchase.Expiry + gracePeriod;
-
-            WaitForStorageContractState(timeout, "started");
-            contractStartedUtc = DateTime.UtcNow;
-            LogStartedDuration();
-            AssertDuration(SubmittedToStarted, timeout, nameof(SubmittedToStarted));
-        }
-
-        public void WaitForStorageContractFinished()
-        {
-            if (!contractStartedUtc.HasValue)
-            {
-                WaitForStorageContractStarted();
-            }
-            var currentContractTime = DateTime.UtcNow - contractSubmittedUtc!.Value;
-            var timeout = (Purchase.Duration - currentContractTime) + gracePeriod;
-            WaitForStorageContractState(timeout, "finished");
-            contractFinishedUtc = DateTime.UtcNow;
-            LogFinishedDuration();
-            AssertDuration(SubmittedToFinished, timeout, nameof(SubmittedToFinished));
-        }
-
-        public StoragePurchase GetPurchaseStatus(string purchaseId)
-        {
-            return codexAccess.GetPurchaseStatus(purchaseId);
-        }
-
-        private void WaitForStorageContractState(TimeSpan timeout, string desiredState, int sleep = 1000)
-        {
-            var lastState = "";
-            var waitStart = DateTime.UtcNow;
-
-            Log($"Waiting for {Time.FormatDuration(timeout)} to reach state '{desiredState}'.");
-            while (lastState != desiredState)
-            {
-                var purchaseStatus = codexAccess.GetPurchaseStatus(PurchaseId);
-                var statusJson = JsonConvert.SerializeObject(purchaseStatus);
-                if (purchaseStatus != null && purchaseStatus.State != lastState)
-                {
-                    lastState = purchaseStatus.State;
-                    log.Debug("Purchase status: " + statusJson);
-                }
-
-                Thread.Sleep(sleep);
-
-                if (lastState == "errored")
-                {
-                    FrameworkAssert.Fail("Contract errored: " + statusJson);
-                }
-
-                if (DateTime.UtcNow - waitStart > timeout)
-                {
-                    FrameworkAssert.Fail($"Contract did not reach '{desiredState}' within {Time.FormatDuration(timeout)} timeout. {statusJson}");
-                }
-            }
-        }
-
-        private void LogSubmittedDuration()
-        {
-            Log($"Pending to Submitted in {Time.FormatDuration(PendingToSubmitted)} " +
-                $"( < {Time.FormatDuration(gracePeriod)})");
-        }
-
-        private void LogStartedDuration()
-        {
-            Log($"Submitted to Started in {Time.FormatDuration(SubmittedToStarted)} " +
-                $"( < {Time.FormatDuration(Purchase.Expiry + gracePeriod)})");
-        }
-
-        private void LogFinishedDuration()
-        {
-            Log($"Submitted to Finished in {Time.FormatDuration(SubmittedToFinished)} " +
-                $"( < {Time.FormatDuration(Purchase.Duration + gracePeriod)})");
-        }
-
-        private void AssertDuration(TimeSpan? span, TimeSpan max, string message)
-        {
-            if (span == null) throw new ArgumentNullException(nameof(MarketplaceAccess) + ": " + message + " (IsNull)");
-            if (span.Value.TotalDays >= max.TotalSeconds)
-            {
-                throw new Exception(nameof(MarketplaceAccess) + 
-                    $": Duration out of range. Max: {Time.FormatDuration(max)} but was: {Time.FormatDuration(span.Value)} " +
-                    message);
-            }
-        }
-
-        private void Log(string msg)
-        {
-            log.Log($"[{PurchaseId}] {msg}");
-        }
-    }
 }

ProjectPlugins/CodexPlugin/StoragePurchaseContract.cs

@@ -0,0 +1,140 @@
+using Logging;
+using Newtonsoft.Json;
+using Utils;
+
+namespace CodexPlugin
+{
+    public interface IStoragePurchaseContract
+    {
+        void WaitForStorageContractSubmitted();
+        void WaitForStorageContractStarted();
+        void WaitForStorageContractFinished();
+    }
+
+    public class StoragePurchaseContract : IStoragePurchaseContract
+    {
+        private readonly ILog log;
+        private readonly CodexAccess codexAccess;
+        private readonly TimeSpan gracePeriod = TimeSpan.FromSeconds(30);
+        private readonly DateTime contractPendingUtc = DateTime.UtcNow;
+        private DateTime? contractSubmittedUtc = DateTime.UtcNow;
+        private DateTime? contractStartedUtc;
+        private DateTime? contractFinishedUtc;
+
+        public StoragePurchaseContract(ILog log, CodexAccess codexAccess, string purchaseId, StoragePurchaseRequest purchase)
+        {
+            this.log = log;
+            this.codexAccess = codexAccess;
+            PurchaseId = purchaseId;
+            Purchase = purchase;
+        }
+
+        public string PurchaseId { get; }
+        public StoragePurchaseRequest Purchase { get; }
+
+        public TimeSpan? PendingToSubmitted => contractSubmittedUtc - contractPendingUtc;
+        public TimeSpan? SubmittedToStarted => contractStartedUtc - contractSubmittedUtc;
+        public TimeSpan? SubmittedToFinished => contractFinishedUtc - contractSubmittedUtc;
+
+        public void WaitForStorageContractSubmitted()
+        {
+            WaitForStorageContractState(gracePeriod, "submitted", sleep: 200);
+            contractSubmittedUtc = DateTime.UtcNow;
+            LogSubmittedDuration();
+            AssertDuration(PendingToSubmitted, gracePeriod, nameof(PendingToSubmitted));
+        }
+
+        public void WaitForStorageContractStarted()
+        {
+            var timeout = Purchase.Expiry + gracePeriod;
+
+            WaitForStorageContractState(timeout, "started");
+            contractStartedUtc = DateTime.UtcNow;
+            LogStartedDuration();
+            AssertDuration(SubmittedToStarted, timeout, nameof(SubmittedToStarted));
+        }
+
+        public void WaitForStorageContractFinished()
+        {
+            if (!contractStartedUtc.HasValue)
+            {
+                WaitForStorageContractStarted();
+            }
+            var currentContractTime = DateTime.UtcNow - contractSubmittedUtc!.Value;
+            var timeout = (Purchase.Duration - currentContractTime) + gracePeriod;
+            WaitForStorageContractState(timeout, "finished");
+            contractFinishedUtc = DateTime.UtcNow;
+            LogFinishedDuration();
+            AssertDuration(SubmittedToFinished, timeout, nameof(SubmittedToFinished));
+        }
+
+        public StoragePurchase GetPurchaseStatus(string purchaseId)
+        {
+            return codexAccess.GetPurchaseStatus(purchaseId);
+        }
+
+        private void WaitForStorageContractState(TimeSpan timeout, string desiredState, int sleep = 1000)
+        {
+            var lastState = "";
+            var waitStart = DateTime.UtcNow;
+
+            Log($"Waiting for {Time.FormatDuration(timeout)} to reach state '{desiredState}'.");
+            while (lastState != desiredState)
+            {
+                var purchaseStatus = codexAccess.GetPurchaseStatus(PurchaseId);
+                var statusJson = JsonConvert.SerializeObject(purchaseStatus);
+                if (purchaseStatus != null && purchaseStatus.State != lastState)
+                {
+                    lastState = purchaseStatus.State;
+                    log.Debug("Purchase status: " + statusJson);
+                }
+
+                Thread.Sleep(sleep);
+
+                if (lastState == "errored")
+                {
+                    FrameworkAssert.Fail("Contract errored: " + statusJson);
+                }
+
+                if (DateTime.UtcNow - waitStart > timeout)
+                {
+                    FrameworkAssert.Fail($"Contract did not reach '{desiredState}' within {Time.FormatDuration(timeout)} timeout. {statusJson}");
+                }
+            }
+        }
+
+        private void LogSubmittedDuration()
+        {
+            Log($"Pending to Submitted in {Time.FormatDuration(PendingToSubmitted)} " +
+                $"( < {Time.FormatDuration(gracePeriod)})");
+        }
+
+        private void LogStartedDuration()
+        {
+            Log($"Submitted to Started in {Time.FormatDuration(SubmittedToStarted)} " +
+                $"( < {Time.FormatDuration(Purchase.Expiry + gracePeriod)})");
+        }
+
+        private void LogFinishedDuration()
+        {
+            Log($"Submitted to Finished in {Time.FormatDuration(SubmittedToFinished)} " +
+                $"( < {Time.FormatDuration(Purchase.Duration + gracePeriod)})");
+        }
+
+        private void AssertDuration(TimeSpan? span, TimeSpan max, string message)
+        {
+            if (span == null) throw new ArgumentNullException(nameof(MarketplaceAccess) + ": " + message + " (IsNull)");
+            if (span.Value.TotalDays >= max.TotalSeconds)
+            {
+                throw new Exception(nameof(MarketplaceAccess) +
+                    $": Duration out of range. Max: {Time.FormatDuration(max)} but was: {Time.FormatDuration(span.Value)} " +
+                    message);
+            }
+        }
+
+        private void Log(string msg)
+        {
+            log.Log($"[{PurchaseId}] {msg}");
+        }
+    }
+}

ProjectPlugins/GethPlugin/EthAccount.cs

@@ -24,5 +24,10 @@ namespace GethPlugin
 
             return new EthAccount(ethAddress, account.PrivateKey);
         }
+
+        public override string ToString()
+        {
+            return EthAddress.ToString();
+        }
     }
 }

Tests/CodexTests/BasicTests/MarketplaceTests.cs

@@ -65,8 +65,8 @@ namespace CodexTests.BasicTests
                 MinRequiredNumberOfNodes = 5,
                 NodeFailureTolerance = 2,
                 ProofProbability = 5,
-                Duration = TimeSpan.FromMinutes(5),
-                Expiry = TimeSpan.FromMinutes(4)
+                Duration = TimeSpan.FromMinutes(6),
+                Expiry = TimeSpan.FromMinutes(5)
             };
 
             var purchaseContract = client.Marketplace.RequestStorage(purchase);

Tests/CodexTests/CodexTests.csproj

@@ -13,11 +13,13 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\Framework\DiscordRewards\DiscordRewards.csproj" />
     <ProjectReference Include="..\..\ProjectPlugins\CodexContractsPlugin\CodexContractsPlugin.csproj" />
     <ProjectReference Include="..\..\ProjectPlugins\CodexDiscordBotPlugin\CodexDiscordBotPlugin.csproj" />
     <ProjectReference Include="..\..\ProjectPlugins\CodexPlugin\CodexPlugin.csproj" />
     <ProjectReference Include="..\..\ProjectPlugins\GethPlugin\GethPlugin.csproj" />
     <ProjectReference Include="..\..\ProjectPlugins\MetricsPlugin\MetricsPlugin.csproj" />
+    <ProjectReference Include="..\..\Tools\TestNetRewarder\TestNetRewarder.csproj" />
     <ProjectReference Include="..\DistTestCore\DistTestCore.csproj" />
   </ItemGroup>
 

Tests/CodexTests/UtilityTests/ClusterSpeedTests.cs

@@ -3,7 +3,7 @@ using Logging;
 using NUnit.Framework;
 using Utils;
 
-namespace CodexTests.ScalabilityTests
+namespace CodexTests.UtilityTests
 {
     [TestFixture]
     public class ClusterDiscSpeedTests : DistTest
@@ -18,7 +18,7 @@ namespace CodexTests.ScalabilityTests
         )
         {
             long targetSize = (long)(1024 * 1024 * 1024) * 2;
-            long bufferSizeBytes = ((long)bufferSizeKb) * 1024;
+            long bufferSizeBytes = (long)bufferSizeKb * 1024;
 
             var filename = nameof(DiscSpeedTest);
 
@@ -28,7 +28,7 @@ namespace CodexTests.ScalabilityTests
             var writeSpeed = PerformWrite(targetSize, bufferSizeBytes, filename);
             Thread.Sleep(2000);
             var readSpeed = PerformRead(targetSize, bufferSizeBytes, filename);
-            
+
             Log($"Write speed: {writeSpeed} per second.");
             Log($"Read speed: {readSpeed} per second.");
         }

Tests/CodexTests/UtilityTests/DiscordBotTests.cs

@@ -1,8 +1,15 @@
 using CodexContractsPlugin;
+using CodexContractsPlugin.Marketplace;
 using CodexDiscordBotPlugin;
 using CodexPlugin;
+using Core;
+using DiscordRewards;
 using GethPlugin;
+using KubernetesWorkflow.Types;
+using Logging;
+using Newtonsoft.Json;
 using NUnit.Framework;
+using TestNetRewarder;
 using Utils;
 
 namespace CodexTests.UtilityTests
@@ -10,21 +17,127 @@ namespace CodexTests.UtilityTests
     [TestFixture]
     public class DiscordBotTests : AutoBootstrapDistTest
     {
+        private readonly RewardRepo repo = new RewardRepo();
+        private readonly TestToken hostInitialBalance = 3000000.TstWei();
+        private readonly TestToken clientInitialBalance = 1000000000.TstWei();
+        private readonly EthAccount clientAccount = EthAccount.GenerateNew();
+        private readonly List<EthAccount> hostAccounts = new List<EthAccount>();
+        private readonly List<ulong> rewardsSeen = new List<ulong>();
+        private readonly TimeSpan rewarderInterval = TimeSpan.FromMinutes(1);
+
         [Test]
-        [Ignore("Used for debugging bots")]
         public void BotRewardTest()
         {
-            var myAccount = EthAccount.GenerateNew();
-
-            var sellerInitialBalance = 234.TstWei();
-            var buyerInitialBalance = 100000.TstWei();
-            var fileSize = 11.MB();
-
             var geth = Ci.StartGethNode(s => s.IsMiner().WithName("disttest-geth"));
             var contracts = Ci.StartCodexContracts(geth);
+            var gethInfo = CreateGethInfo(geth, contracts);
 
-            // start bot and rewarder
-            var gethInfo = new DiscordBotGethInfo(
+            var monitor = new ChainMonitor(contracts, geth, GetTestLog());
+            monitor.Start();
+
+            var botContainer = StartDiscordBot(gethInfo);
+
+            StartHosts(geth, contracts);
+
+            var rewarderContainer = StartRewarderBot(gethInfo, botContainer);
+
+            var client = StartClient(geth, contracts);
+
+            var apiCalls = new RewardApiCalls(Ci, botContainer);
+            apiCalls.Start(OnCommand);
+            var rewarderLog = new RewarderLogMonitor(Ci, rewarderContainer.Containers.Single());
+            rewarderLog.Start(l => Log("Rewarder ChainState: " + l));
+
+            var purchaseContract = ClientPurchasesStorage(client);
+            purchaseContract.WaitForStorageContractFinished();
+
+            rewarderLog.Stop();
+            apiCalls.Stop();
+            monitor.Stop();
+
+            Log("Done!");
+
+            Thread.Sleep(rewarderInterval * 2);
+
+            Log("Seen:");
+            foreach (var seen in rewardsSeen)
+            {
+                Log(seen.ToString());
+            }
+            Log("");
+
+            foreach (var r in repo.Rewards)
+            {
+                var seen = rewardsSeen.Any(s => r.RoleId == s);
+
+                Log($"{r.RoleId} = {seen}");
+            }
+
+            Assert.That(repo.Rewards.All(r => rewardsSeen.Contains(r.RoleId)));
+        }
+
+        private void OnCommand(GiveRewardsCommand call)
+        {
+            if (call.Averages.Any()) Log($"{call.Averages.Length} average.");
+            if (call.EventsOverview.Any()) Log($"{call.EventsOverview.Length} events.");
+            foreach (var r in call.Rewards)
+            {
+                var reward = repo.Rewards.Single(a => a.RoleId == r.RewardId);
+                if (r.UserAddresses.Any()) rewardsSeen.Add(reward.RoleId);
+                foreach (var address in r.UserAddresses)
+                {
+                    var user = IdentifyAccount(address);
+                    Log(user + ": " + reward.Message);
+                }
+            }
+        }
+
+        private IStoragePurchaseContract ClientPurchasesStorage(ICodexNode client)
+        {
+            var testFile = GenerateTestFile(GetMinFileSize());
+            var contentId = client.UploadFile(testFile);
+            var purchase = new StoragePurchaseRequest(contentId)
+            {
+                PricePerSlotPerSecond = 2.TstWei(),
+                RequiredCollateral = 10.TstWei(),
+                MinRequiredNumberOfNodes = GetNumberOfRequiredHosts(),
+                NodeFailureTolerance = 2,
+                ProofProbability = 5,
+                Duration = TimeSpan.FromMinutes(6),
+                Expiry = TimeSpan.FromMinutes(5)
+            };
+
+            return client.Marketplace.RequestStorage(purchase);
+        }
+
+        private ICodexNode StartClient(IGethNode geth, ICodexContracts contracts)
+        {
+            var node = StartCodex(s => s
+                .WithName("Client")
+                .EnableMarketplace(geth, contracts, m => m
+                    .WithAccount(clientAccount)
+                    .WithInitial(10.Eth(), clientInitialBalance)));
+
+            Log($"Client {node.EthAccount.EthAddress}");
+            return node;
+        }
+
+        private RunningPod StartRewarderBot(DiscordBotGethInfo gethInfo, RunningContainer botContainer)
+        {
+            return Ci.DeployRewarderBot(new RewarderBotStartupConfig(
+                name: "rewarder-bot",
+                discordBotHost: botContainer.GetInternalAddress(DiscordBotContainerRecipe.RewardsPort).Host,
+                discordBotPort: botContainer.GetInternalAddress(DiscordBotContainerRecipe.RewardsPort).Port,
+                intervalMinutes: Convert.ToInt32(Math.Round(rewarderInterval.TotalMinutes)),
+                historyStartUtc: DateTime.UtcNow,
+                gethInfo: gethInfo,
+                dataPath: null
+            ));
+        }
+
+        private DiscordBotGethInfo CreateGethInfo(IGethNode geth, ICodexContracts contracts)
+        {
+            return new DiscordBotGethInfo(
                 host: geth.Container.GetInternalAddress(GethContainerRecipe.HttpPortTag).Host,
                 port: geth.Container.GetInternalAddress(GethContainerRecipe.HttpPortTag).Port,
                 privKey: geth.StartResult.Account.PrivateKey,
@@ -32,8 +145,12 @@ namespace CodexTests.UtilityTests
                 tokenAddress: contracts.Deployment.TokenAddress,
                 abi: contracts.Deployment.Abi
             );
+        }
+
+        private RunningContainer StartDiscordBot(DiscordBotGethInfo gethInfo)
+        {
             var bot = Ci.DeployCodexDiscordBot(new DiscordBotStartupConfig(
-                name: "bot",
+                name: "discord-bot",
                 token: "aaa",
                 serverName: "ThatBen's server",
                 adminRoleName: "bottest-admins",
@@ -42,70 +159,294 @@ namespace CodexTests.UtilityTests
                 kubeNamespace: "notneeded",
                 gethInfo: gethInfo
             ));
-            var botContainer = bot.Containers.Single();
-            Ci.DeployRewarderBot(new RewarderBotStartupConfig(
-                //discordBotHost: "http://" + botContainer.GetAddress(GetTestLog(), DiscordBotContainerRecipe.RewardsPort).Host,
-                //discordBotPort: botContainer.GetAddress(GetTestLog(), DiscordBotContainerRecipe.RewardsPort).Port,
-                discordBotHost: botContainer.GetInternalAddress(DiscordBotContainerRecipe.RewardsPort).Host,
-                discordBotPort: botContainer.GetInternalAddress(DiscordBotContainerRecipe.RewardsPort).Port,
-                intervalMinutes: "1",
-                historyStartUtc: GetTestRunTimeRange().From - TimeSpan.FromMinutes(3),
-                gethInfo: gethInfo,
-                dataPath: null
-            ));
+            return bot.Containers.Single();
+        }
 
-            var numberOfHosts = 3;
+        private void StartHosts(IGethNode geth, ICodexContracts contracts)
+        {
+            var hosts = StartCodex(GetNumberOfLiveHosts(), s => s
+                .WithName("Host")
+                .WithLogLevel(CodexLogLevel.Trace, new CodexLogCustomTopics(CodexLogLevel.Error, CodexLogLevel.Error, CodexLogLevel.Warn)
+                {
+                    ContractClock = CodexLogLevel.Trace,
+                })
+                .WithStorageQuota(Mult(GetMinFileSizePlus(50), GetNumberOfLiveHosts()))
+                .EnableMarketplace(geth, contracts, m => m
+                    .WithInitial(10.Eth(), hostInitialBalance)
+                    .AsStorageNode()
+                    .AsValidator()));
 
-            for (var i = 0; i < numberOfHosts; i++)
+            var availability = new StorageAvailability(
+                totalSpace: Mult(GetMinFileSize(), GetNumberOfLiveHosts()),
+                maxDuration: TimeSpan.FromMinutes(30),
+                minPriceForTotalSpace: 1.TstWei(),
+                maxCollateral: hostInitialBalance
+            );
+
+            foreach (var host in hosts)
             {
-                var seller = StartCodex(s => s
-                    .WithName("Seller")
-                    .WithLogLevel(CodexLogLevel.Trace, new CodexLogCustomTopics(CodexLogLevel.Error, CodexLogLevel.Error, CodexLogLevel.Warn)
-                    {
-                        ContractClock = CodexLogLevel.Trace,
-                    })
-                    .WithStorageQuota(11.GB())
-                    .EnableMarketplace(geth, contracts, m => m
-                        .WithAccount(myAccount)
-                        .WithInitial(10.Eth(), sellerInitialBalance)
-                        .AsStorageNode()
-                        .AsValidator()));
+                hostAccounts.Add(host.EthAccount);
+                host.Marketplace.MakeStorageAvailable(availability);
+            }
+        }
 
-                var availability = new StorageAvailability(
-                    totalSpace: 10.GB(),
-                    maxDuration: TimeSpan.FromMinutes(30),
-                    minPriceForTotalSpace: 1.TstWei(),
-                    maxCollateral: 20.TstWei()
-                );
-                seller.Marketplace.MakeStorageAvailable(availability);
+        private int GetNumberOfLiveHosts()
+        {
+            return Convert.ToInt32(GetNumberOfRequiredHosts()) + 3;
+        }
+
+        private ByteSize Mult(ByteSize size, int mult)
+        {
+            return new ByteSize(size.SizeInBytes * mult);
+        }
+
+        private ByteSize GetMinFileSizePlus(int plusMb)
+        {
+            return new ByteSize(GetMinFileSize().SizeInBytes + plusMb.MB().SizeInBytes);
+        }
+
+        private ByteSize GetMinFileSize()
+        {
+            ulong minSlotSize = 0;
+            ulong minNumHosts = 0;
+            foreach (var r in repo.Rewards)
+            {
+                var s = Convert.ToUInt64(r.CheckConfig.MinSlotSize.SizeInBytes);
+                var h = r.CheckConfig.MinNumberOfHosts;
+                if (s > minSlotSize) minSlotSize = s;
+                if (h > minNumHosts) minNumHosts = h;
             }
 
-            var testFile = GenerateTestFile(fileSize);
+            var minFileSize = ((minSlotSize + 1024) * minNumHosts);
+            return new ByteSize(Convert.ToInt64(minFileSize));
+        }
 
-            var buyer = StartCodex(s => s
-                .WithName("Buyer")
-                .EnableMarketplace(geth, contracts, m => m
-                    .WithAccount(myAccount)
-                    .WithInitial(10.Eth(), buyerInitialBalance)));
+        private uint GetNumberOfRequiredHosts()
+        {
+            return Convert.ToUInt32(repo.Rewards.Max(r => r.CheckConfig.MinNumberOfHosts));
+        }
 
-            var contentId = buyer.UploadFile(testFile);
-
-            var purchase = new StoragePurchaseRequest(contentId)
+        private string IdentifyAccount(string address)
+        {
+            if (address == clientAccount.EthAddress.Address) return "Client";
+            try
             {
-                PricePerSlotPerSecond = 2.TstWei(),
-                RequiredCollateral = 10.TstWei(),
-                MinRequiredNumberOfNodes = 5,
-                NodeFailureTolerance = 2,
-                ProofProbability = 5,
-                Duration = TimeSpan.FromMinutes(6),
-                Expiry = TimeSpan.FromMinutes(5)
-            };
+                var index = hostAccounts.FindIndex(a => a.EthAddress.Address == address);
+                return "Host" + index;
+            }
+            catch
+            {
+                return "UNKNOWN";
+            }
+        }
 
-            var purchaseContract = buyer.Marketplace.RequestStorage(purchase);
+        public class RewardApiCalls
+        {
+            private readonly ContainerFileMonitor monitor;
+            private readonly Dictionary<string, GiveRewardsCommand> commands = new Dictionary<string, GiveRewardsCommand>();
 
-            purchaseContract.WaitForStorageContractStarted();
+            public RewardApiCalls(CoreInterface ci, RunningContainer botContainer)
+            {
+                monitor = new ContainerFileMonitor(ci, botContainer, "/app/datapath/logs/discordbot.log");
+            }
 
-            purchaseContract.WaitForStorageContractFinished();
+            public void Start(Action<GiveRewardsCommand> onCommand)
+            {
+                monitor.Start(line => ParseLine(line, onCommand));
+            }
+
+            public void Stop()
+            {
+                monitor.Stop();
+            }
+
+            private void ParseLine(string line, Action<GiveRewardsCommand> onCommand)
+            {
+                try
+                {
+                    var timestamp = line.Substring(0, 30);
+                    if (commands.ContainsKey(timestamp)) return;
+                    var json = line.Substring(31);
+
+                    var cmd = JsonConvert.DeserializeObject<GiveRewardsCommand>(json);
+                    if (cmd != null)
+                    {
+                        commands.Add(timestamp, cmd);
+                        onCommand(cmd);
+                    }
+                }
+                catch
+                {
+                }
+            }
+        }
+
+        public class RewarderLogMonitor
+        {
+            private readonly ContainerFileMonitor monitor;
+            private readonly Dictionary<string, GiveRewardsCommand> commands = new Dictionary<string, GiveRewardsCommand>();
+
+            public RewarderLogMonitor(CoreInterface ci, RunningContainer botContainer)
+            {
+                monitor = new ContainerFileMonitor(ci, botContainer, "/app/datapath/logs/testnetrewarder.log");
+            }
+
+            public void Start(Action<string> onCommand)
+            {
+                monitor.Start(l => ProcessLine(l, onCommand));
+            }
+
+            public void Stop()
+            {
+                monitor.Stop();
+            }
+
+            private void ProcessLine(string line, Action<string> log)
+            {
+                //$"ChainState=[{JsonConvert.SerializeObject(this)}]" +
+                //$"HistoricState=[{historicState.EntireString()}]";
+
+                var stateOpenTag = "ChainState=[";
+                var historicOpenTag = "]HistoricState=[";
+
+                if (!line.Contains(stateOpenTag)) return;
+                if (!line.Contains(historicOpenTag)) return;
+
+                var stateStr = Between(line, stateOpenTag, historicOpenTag);
+                var historicStr = Between(line, historicOpenTag, "]");
+
+                var chainState = JsonConvert.DeserializeObject<ChainState>(stateStr);
+                var historicState = JsonConvert.DeserializeObject<TestNetRewarder.StorageRequest[]>(historicStr)!;
+                chainState!.Set(new HistoricState(historicState));
+
+                log(string.Join(",", chainState!.GenerateOverview()));
+            }
+
+            private string Between(string s, string open, string close)
+            {
+                var start = s.IndexOf(open) + open.Length;
+                var end = s.LastIndexOf(close);
+                return s.Substring(start, end - start);
+            }
+        }
+
+        public class ContainerFileMonitor
+        {
+            private readonly CoreInterface ci;
+            private readonly RunningContainer botContainer;
+            private readonly string filePath;
+            private readonly CancellationTokenSource cts = new CancellationTokenSource();
+            private readonly List<string> seenLines = new List<string>();
+            private Task worker = Task.CompletedTask;
+            private Action<string> onNewLine = c => { };
+
+            public ContainerFileMonitor(CoreInterface ci, RunningContainer botContainer, string filePath)
+            {
+                this.ci = ci;
+                this.botContainer = botContainer;
+                this.filePath = filePath;
+            }
+
+            public void Start(Action<string> onNewLine)
+            {
+                this.onNewLine = onNewLine;
+                worker = Task.Run(Worker);
+            }
+
+            public void Stop()
+            {
+                cts.Cancel();
+                worker.Wait();
+            }
+
+            private void Worker()
+            {
+                while (!cts.IsCancellationRequested)
+                {
+                    Update();
+                }
+            }
+
+            private void Update()
+            {
+                Thread.Sleep(TimeSpan.FromSeconds(10));
+                if (cts.IsCancellationRequested) return;
+
+                var botLog = ci.ExecuteContainerCommand(botContainer, "cat", filePath);
+                var lines = botLog.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+                foreach (var line in lines)
+                {
+                    if (!seenLines.Contains(line))
+                    {
+                        seenLines.Add(line);
+                        onNewLine(line);
+                    }
+                }
+            }
+        }
+
+        public class ChainMonitor
+        {
+            private readonly ICodexContracts contracts;
+            private readonly IGethNode geth;
+            private readonly ILog log;
+            private readonly CancellationTokenSource cts = new CancellationTokenSource();
+            private Task worker = Task.CompletedTask;
+            private DateTime last = DateTime.UtcNow;
+
+            public ChainMonitor(ICodexContracts contracts, IGethNode geth, ILog log)
+            {
+                this.contracts = contracts;
+                this.geth = geth;
+                this.log = log;
+            }
+
+            public void Start()
+            {
+                last = DateTime.UtcNow;
+                worker = Task.Run(Worker);
+            }
+
+            public void Stop()
+            {
+                cts.Cancel();
+                worker.Wait();
+            }
+
+            private void Worker()
+            {
+                while (!cts.IsCancellationRequested)
+                {
+                    Thread.Sleep(TimeSpan.FromSeconds(10));
+                    if (cts.IsCancellationRequested) return;
+
+                    Update();
+
+                }
+            }
+
+            private void Update()
+            {
+                var start = last;
+                var stop = DateTime.UtcNow;
+                last = stop;
+
+                var range = geth.ConvertTimeRangeToBlockRange(new TimeRange(start, stop));
+
+
+                LogEvents(nameof(contracts.GetStorageRequests), contracts.GetStorageRequests, range);
+                LogEvents(nameof(contracts.GetRequestFulfilledEvents), contracts.GetRequestFulfilledEvents, range);
+                LogEvents(nameof(contracts.GetRequestCancelledEvents), contracts.GetRequestCancelledEvents, range);
+                LogEvents(nameof(contracts.GetSlotFilledEvents), contracts.GetSlotFilledEvents, range);
+                LogEvents(nameof(contracts.GetSlotFreedEvents), contracts.GetSlotFreedEvents, range);
+            }
+
+            private void LogEvents(string n, Func<BlockInterval, object> f, BlockInterval r)
+            {
+                var a = (object[])f(r);
+
+                a.ToList().ForEach(request => log.Log(n + " - " + JsonConvert.SerializeObject(request)));
+            }
         }
     }
 }

Tools/BiblioTech/Configuration.cs

@@ -35,28 +35,12 @@ namespace BiblioTech
         [Uniform("mint-tt", "mt", "MINTTT", true, "Amount of TSTWEI minted by the mint command.")]
         public BigInteger MintTT { get; set; } = 1073741824;
 
-        public string EndpointsPath
-        {
-            get
-            {
-                return Path.Combine(DataPath, "endpoints");
-            }
-        }
+        [Uniform("no-discord", "nd", "NODISCORD", false, "For debugging: Bypasses all Discord API calls.")]
+        public int NoDiscord { get; set; } = 0;
 
-        public string UserDataPath
-        {
-            get
-            {
-                return Path.Combine(DataPath, "users");
-            }
-        }
-
-        public string LogPath
-        {
-            get
-            {
-                return Path.Combine(DataPath, "logs");
-            }
-        }
+        public string EndpointsPath => Path.Combine(DataPath, "endpoints");
+        public string UserDataPath => Path.Combine(DataPath, "users");
+        public string LogPath => Path.Combine(DataPath, "logs");
+        public bool DebugNoDiscord => NoDiscord == 1;
     }
 }

Tools/BiblioTech/LoggingRoleDriver.cs

@@ -0,0 +1,24 @@
+using BiblioTech.Rewards;
+using DiscordRewards;
+using Logging;
+using Newtonsoft.Json;
+
+namespace BiblioTech
+{
+    public class LoggingRoleDriver : IDiscordRoleDriver
+    {
+        private readonly ILog log;
+
+        public LoggingRoleDriver(ILog log)
+        {
+            this.log = log;
+        }
+
+        public async Task GiveRewards(GiveRewardsCommand rewards)
+        {
+            await Task.CompletedTask;
+
+            log.Log(JsonConvert.SerializeObject(rewards, Formatting.None));
+        }
+    }
+}

Tools/BiblioTech/Program.cs

@@ -41,25 +41,15 @@ namespace BiblioTech
         public async Task MainAsync(string[] args)
         {
             Log.Log("Starting Codex Discord Bot...");
-            client = new DiscordSocketClient();
-            client.Log += ClientLog;
-
-            var notifyCommand = new NotifyCommand();
-            var associateCommand = new UserAssociateCommand(notifyCommand);
-            var sprCommand = new SprCommand();
-            var handler = new CommandHandler(client,
-                new GetBalanceCommand(associateCommand), 
-                new MintCommand(associateCommand),
-                sprCommand,
-                associateCommand,
-                notifyCommand,
-                new AdminCommand(sprCommand),
-                new MarketCommand()
-            );
-
-            await client.LoginAsync(TokenType.Bot, Config.ApplicationToken);
-            await client.StartAsync();
-            AdminChecker = new AdminChecker();
+            if (Config.DebugNoDiscord)
+            {
+                Log.Log("Debug option is set. Discord connection disabled!");
+                RoleDriver = new LoggingRoleDriver(Log);
+            }
+            else
+            {
+                await StartDiscordBot();
+            }
 
             var builder = WebApplication.CreateBuilder(args);
             builder.WebHost.ConfigureKestrel((context, options) =>
@@ -75,6 +65,29 @@ namespace BiblioTech
             await Task.Delay(-1);
         }
 
+        private async Task StartDiscordBot()
+        {
+            client = new DiscordSocketClient();
+            client.Log += ClientLog;
+
+            var notifyCommand = new NotifyCommand();
+            var associateCommand = new UserAssociateCommand(notifyCommand);
+            var sprCommand = new SprCommand();
+            var handler = new CommandHandler(client,
+                new GetBalanceCommand(associateCommand),
+                new MintCommand(associateCommand),
+                sprCommand,
+                associateCommand,
+                notifyCommand,
+                new AdminCommand(sprCommand),
+                new MarketCommand()
+            );
+
+            await client.LoginAsync(TokenType.Bot, Config.ApplicationToken);
+            await client.StartAsync();
+            AdminChecker = new AdminChecker();
+        }
+
         private static void PrintHelp()
         {
             Log.Log("BiblioTech - Codex Discord Bot");

Tools/TestNetRewarder/ChainState.cs

@@ -8,7 +8,7 @@ namespace TestNetRewarder
 {
     public class ChainState
     {
-        private readonly HistoricState historicState;
+        private HistoricState historicState;
         private readonly string[] colorIcons = new[]
         {
             "🔴",
@@ -50,15 +50,48 @@ namespace TestNetRewarder
             SlotFreedEvents = contracts.GetSlotFreedEvents(blockRange);
         }
 
+        public ChainState(
+            Request[] newRequests,
+            RequestFulfilledEventDTO[] requestFulfilledEvents,
+            RequestCancelledEventDTO[] requestCancelledEvents,
+             SlotFilledEventDTO[] slotFilledEvents,
+             SlotFreedEventDTO[] slotFreedEvents)
+        {
+            NewRequests = newRequests;
+            RequestFulfilledEvents = requestFulfilledEvents;
+            RequestCancelledEvents = requestCancelledEvents;
+            SlotFilledEvents = slotFilledEvents;
+            SlotFreedEvents = slotFreedEvents;
+
+            historicState = new HistoricState();
+            StartedRequests = Array.Empty<StorageRequest>();
+            FinishedRequests = Array.Empty<StorageRequest>();
+        }
+
         public Request[] NewRequests { get; }
+        [JsonIgnore]
         public StorageRequest[] AllRequests => historicState.StorageRequests;
+        [JsonIgnore]
         public StorageRequest[] StartedRequests { get; private set; }
+        [JsonIgnore]
         public StorageRequest[] FinishedRequests { get; private set; }
         public RequestFulfilledEventDTO[] RequestFulfilledEvents { get; }
         public RequestCancelledEventDTO[] RequestCancelledEvents { get; }
         public SlotFilledEventDTO[] SlotFilledEvents { get; }
         public SlotFreedEventDTO[] SlotFreedEvents { get; }
 
+        public string EntireString()
+        {
+            return
+                $"ChainState=[{JsonConvert.SerializeObject(this)}]" +
+                $"HistoricState=[{historicState.EntireString()}]";
+        }
+
+        public void Set(HistoricState h)
+        {
+            historicState = h;
+        }
+
         public string[] GenerateOverview()
         {
             var entries = new List<StringBlockNumberPair>();

Tools/TestNetRewarder/HistoricState.cs

@@ -29,6 +29,20 @@ namespace TestNetRewarder
                 r.State == RequestState.Failed
             );
         }
+
+        public string EntireString()
+        {
+            return JsonConvert.SerializeObject(StorageRequests);
+        }
+
+        public HistoricState()
+        {
+        }
+
+        public HistoricState(StorageRequest[] requests)
+        {
+            storageRequests.AddRange(requests);
+        }
     }
 
     public class StorageRequest

Tools/TestNetRewarder/Processor.cs

@@ -58,6 +58,8 @@ namespace TestNetRewarder
 
         private async Task ProcessChainState(ChainState chainState)
         {
+            log.Log(chainState.EntireString());
+
             var outgoingRewards = new List<RewardUsersCommand>();
             foreach (var reward in rewardRepo.Rewards)
             {