Set up contract-failed event.

Author: benbierens

Framework/Utils/RollingAverage.cs

@@ -0,0 +1,21 @@
+namespace Utils
+{
+    public static class RollingAverage
+    {
+        /// <param name="currentAverage">Value of average before new value is added.</param>
+        /// <param name="newNumberOfValues">Number of values in average after new value is added.</param>
+        /// <param name="newValue">New value to be added.</param>
+        /// <returns>New average value.</returns>
+        /// <exception cref="Exception">newNumberOfValues must be 1 or greater.</exception>
+        public static float GetNewAverage(float currentAverage, int newNumberOfValues, float newValue)
+        {
+            if (newNumberOfValues < 1) throw new Exception("Should be at least 1 value.");
+
+            float n = newNumberOfValues;
+            var originalValue = currentAverage;
+            var originalValueWeight = ((n - 1.0f) / n);
+            var newValueWeight = (1.0f / n);
+            return (originalValue * originalValueWeight) + (newValue * newValueWeight);
+        }
+    }
+}

ProjectPlugins/CodexContractsPlugin/ChainMonitor/ChainEvents.cs

@@ -10,6 +10,7 @@ private ChainEvents(
             Request[] requests,
             RequestFulfilledEventDTO[] fulfilled,
             RequestCancelledEventDTO[] cancelled,
+            RequestFailedEventDTO[] failed,
             SlotFilledEventDTO[] slotFilled,
             SlotFreedEventDTO[] slotFreed
             )
@@ -18,6 +19,7 @@ SlotFreedEventDTO[] slotFreed
             Requests = requests;
             Fulfilled = fulfilled;
             Cancelled = cancelled;
+            Failed = failed;
             SlotFilled = slotFilled;
             SlotFreed = slotFreed;
         }
@@ -26,6 +28,7 @@ SlotFreedEventDTO[] slotFreed
         public Request[] Requests { get; }
         public RequestFulfilledEventDTO[] Fulfilled { get; }
         public RequestCancelledEventDTO[] Cancelled { get; }
+        public RequestFailedEventDTO[] Failed { get; }
         public SlotFilledEventDTO[] SlotFilled { get; }
         public SlotFreedEventDTO[] SlotFreed { get; }
 
@@ -37,6 +40,7 @@ public IHasBlock[] All
                 all.AddRange(Requests);
                 all.AddRange(Fulfilled);
                 all.AddRange(Cancelled);
+                all.AddRange(Failed);
                 all.AddRange(SlotFilled);
                 all.AddRange(SlotFreed);
                 return all.ToArray();
@@ -60,6 +64,7 @@ public static ChainEvents FromContractEvents(ICodexContractsEvents events)
                 events.GetStorageRequests(),
                 events.GetRequestFulfilledEvents(),
                 events.GetRequestCancelledEvents(),
+                events.GetRequestFailedEvents(),
                 events.GetSlotFilledEvents(),
                 events.GetSlotFreedEvents()
             );

ProjectPlugins/CodexContractsPlugin/ChainMonitor/ChainState.cs

@@ -13,6 +13,7 @@ public interface IChainStateChangeHandler
         void OnRequestFinished(RequestEvent requestEvent);
         void OnRequestFulfilled(RequestEvent requestEvent);
         void OnRequestCancelled(RequestEvent requestEvent);
+        void OnRequestFailed(RequestEvent requestEvent);
         void OnSlotFilled(RequestEvent requestEvent, EthAddress host, BigInteger slotIndex);
         void OnSlotFreed(RequestEvent requestEvent, BigInteger slotIndex);
     }
@@ -41,15 +42,12 @@ public ChainState(ILog log, ICodexContracts contracts, IChainStateChangeHandler
             this.log = new LogPrefixer(log, "(ChainState) ");
             this.contracts = contracts;
             handler = changeHandler;
-            StartUtc = startUtc;
             TotalSpan = new TimeRange(startUtc, startUtc);
         }
 
         public TimeRange TotalSpan { get; private set; }
         public IChainStateRequest[] Requests => requests.ToArray();
 
-        public DateTime StartUtc { get; }
-
         public void Update()
         {
             Update(DateTime.UtcNow);
@@ -124,6 +122,14 @@ private void ApplyEvent(RequestCancelledEventDTO @event)
             handler.OnRequestCancelled(new RequestEvent(@event.Block, r));
         }
 
+        private void ApplyEvent(RequestFailedEventDTO @event)
+        {
+            var r = FindRequest(@event.RequestId);
+            if (r == null) return;
+            r.UpdateState(@event.Block.BlockNumber, RequestState.Failed);
+            handler.OnRequestFailed(new RequestEvent(@event.Block, r));
+        }
+
         private void ApplyEvent(SlotFilledEventDTO @event)
         {
             var r = FindRequest(@event.RequestId);

ProjectPlugins/CodexContractsPlugin/ChainMonitor/ChainStateChangeHandlerMux.cs

@@ -0,0 +1,55 @@
+using GethPlugin;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CodexContractsPlugin.ChainMonitor
+{
+    public class ChainStateChangeHandlerMux : IChainStateChangeHandler
+    {
+        public ChainStateChangeHandlerMux(params IChainStateChangeHandler[] handlers)
+        {
+            Handlers = handlers.ToList();
+        }
+
+        public List<IChainStateChangeHandler> Handlers { get; } = new List<IChainStateChangeHandler>();
+
+        public void OnNewRequest(RequestEvent requestEvent)
+        {
+            foreach (var handler in Handlers) handler.OnNewRequest(requestEvent);
+        }
+
+        public void OnRequestCancelled(RequestEvent requestEvent)
+        {
+            foreach (var handler in Handlers) handler.OnRequestCancelled(requestEvent);
+        }
+
+        public void OnRequestFailed(RequestEvent requestEvent)
+        {
+            foreach (var handler in Handlers) handler.OnRequestFailed(requestEvent);
+        }
+
+        public void OnRequestFinished(RequestEvent requestEvent)
+        {
+            foreach (var handler in Handlers) handler.OnRequestFinished(requestEvent);
+        }
+
+        public void OnRequestFulfilled(RequestEvent requestEvent)
+        {
+            foreach (var handler in Handlers) handler.OnRequestFulfilled(requestEvent);
+        }
+
+        public void OnSlotFilled(RequestEvent requestEvent, EthAddress host, BigInteger slotIndex)
+        {
+            foreach (var handler in Handlers) handler.OnSlotFilled(requestEvent, host, slotIndex);
+        }
+
+        public void OnSlotFreed(RequestEvent requestEvent, BigInteger slotIndex)
+        {
+            foreach (var handler in Handlers) handler.OnSlotFreed(requestEvent, slotIndex);
+        }
+    }
+}

ProjectPlugins/CodexContractsPlugin/ChainMonitor/DoNothingChainEventHandler.cs

@@ -13,6 +13,10 @@ public void OnRequestCancelled(RequestEvent requestEvent)
         {
         }
 
+        public void OnRequestFailed(RequestEvent requestEvent)
+        {
+        }
+
         public void OnRequestFinished(RequestEvent requestEvent)
         {
         }

ProjectPlugins/CodexContractsPlugin/CodexContractsEvents.cs

@@ -13,6 +13,7 @@ public interface ICodexContractsEvents
         Request[] GetStorageRequests();
         RequestFulfilledEventDTO[] GetRequestFulfilledEvents();
         RequestCancelledEventDTO[] GetRequestCancelledEvents();
+        RequestFailedEventDTO[] GetRequestFailedEvents();
         SlotFilledEventDTO[] GetSlotFilledEvents();
         SlotFreedEventDTO[] GetSlotFreedEvents();
     }
@@ -71,6 +72,17 @@ public RequestCancelledEventDTO[] GetRequestCancelledEvents()
             }).ToArray();
         }
 
+        public RequestFailedEventDTO[] GetRequestFailedEvents()
+        {
+            var events = gethNode.GetEvents<RequestFailedEventDTO>(deployment.MarketplaceAddress, BlockInterval);
+            return events.Select(e =>
+            {
+                var result = e.Event;
+                result.Block = GetBlock(e.Log.BlockNumber.ToUlong());
+                return result;
+            }).ToArray();
+        }
+
         public SlotFilledEventDTO[] GetSlotFilledEvents()
         {
             var events = gethNode.GetEvents<SlotFilledEventDTO>(deployment.MarketplaceAddress, BlockInterval);

ProjectPlugins/CodexContractsPlugin/Marketplace/Customizations.cs

@@ -40,6 +40,12 @@ public partial class RequestCancelledEventDTO : IHasBlock
         public BlockTimeEntry Block { get; set; }
     }
 
+    public partial class RequestFailedEventDTO : IHasBlock
+    {
+        [JsonIgnore]
+        public BlockTimeEntry Block { get; set; }
+    }
+
     public partial class SlotFilledEventDTO : IHasBlock
     {
         [JsonIgnore]

Tests/FrameworkTests/Utils/TimeTests.cs

@@ -21,5 +21,16 @@ public void Timespan()
                 TimeSpan.FromSeconds(28)
             ));
         }
+
+        [Test]
+        public void Averaging()
+        {
+            var first = RollingAverage.GetNewAverage(0.0f, 1, 1.0f);
+            Assert.That(first, Is.EqualTo(1.0f));
+
+            var fifth = RollingAverage.GetNewAverage(5.0f, 5, 0.0f);
+            var expected = new[] { 5.0f, 5.0f, 5.0f, 5.0f, 0.0f }.Average();
+            Assert.That(fifth, Is.EqualTo(expected));
+        }
     }
 }

Tools/MarketInsights/AppState.cs

@@ -0,0 +1,13 @@
+namespace MarketInsights
+{
+    public class AppState
+    {
+        public AppState(Configuration config)
+        {
+            Config = config;
+        }
+
+        public MarketOverview MarketOverview { get; set; } = new ();
+        public Configuration Config { get; }
+    }
+}

Tools/MarketInsights/AverageHistory.cs

@@ -0,0 +1,71 @@
+using CodexContractsPlugin.ChainMonitor;
+using GethPlugin;
+using System.Numerics;
+using Utils;
+
+namespace MarketInsights
+{
+    public class AverageHistory
+    {
+        public readonly List<MarketTimeSegment> contributions = new List<MarketTimeSegment>();
+
+    }
+
+    public class ContributionBuilder : IChainStateChangeHandler
+    {
+        private readonly MarketTimeSegment segment = new MarketTimeSegment();
+
+        public void OnNewRequest(RequestEvent requestEvent)
+        {
+            AddRequestToAverage(segment.Submitted, requestEvent);
+        }
+
+        public void OnRequestCancelled(RequestEvent requestEvent)
+        {
+            AddRequestToAverage(segment.Expired, requestEvent);
+        }
+
+        public void OnRequestFailed(RequestEvent requestEvent)
+        {
+            AddRequestToAverage(segment.Failed, requestEvent);
+        }
+
+        public void OnRequestFinished(RequestEvent requestEvent)
+        {
+            AddRequestToAverage(segment.Finished, requestEvent);
+        }
+
+        public void OnRequestFulfilled(RequestEvent requestEvent)
+        {
+            AddRequestToAverage(segment.Started, requestEvent);
+        }
+
+        public void OnSlotFilled(RequestEvent requestEvent, EthAddress host, BigInteger slotIndex)
+        {
+        }
+
+        public void OnSlotFreed(RequestEvent requestEvent, BigInteger slotIndex)
+        {
+        }
+
+        private void AddRequestToAverage(ContractAverages average, RequestEvent requestEvent)
+        {
+            average.Number++;
+            average.Price = GetNewAverage(average.Price, average.Number, requestEvent.Request.Request.Ask.Reward);
+            average.Size = GetNewAverage(average.Size, average.Number, requestEvent.Request.Request.Ask.SlotSize);
+            average.Duration = GetNewAverage(average.Duration, average.Number, requestEvent.Request.Request.Ask.Duration);
+            average.Collateral = GetNewAverage(average.Collateral, average.Number, requestEvent.Request.Request.Ask.Collateral);
+            average.ProofProbability = GetNewAverage(average.ProofProbability, average.Number, requestEvent.Request.Request.Ask.ProofProbability);
+        }
+
+        private float GetNewAverage(float currentAverage, int newNumberOfValues, BigInteger newValue)
+        {
+            return GetNewAverage(currentAverage, newNumberOfValues, (float)newValue);
+        }
+
+        private float GetNewAverage(float currentAverage, int newNumberOfValues, float newValue)
+        {
+            return RollingAverage.GetNewAverage(currentAverage, newNumberOfValues, newValue);
+        }
+    }
+}