diff --git a/chain/build.gradle b/chain/build.gradle
index 5923f3bdd..6ee0b27e3 100644
--- a/chain/build.gradle
+++ b/chain/build.gradle
@@ -6,7 +6,7 @@ dependencies {
   implementation project(':db:core')
   implementation project(':pow:core')
   api project(':ssz')
-  implementation project(':util')
+  implementation project(':util:core')
 
   implementation 'com.google.guava:guava'
   implementation 'io.projectreactor:reactor-core'
diff --git a/consensus/build.gradle b/consensus/build.gradle
index 641584600..4c6ef3dcf 100644
--- a/consensus/build.gradle
+++ b/consensus/build.gradle
@@ -3,7 +3,7 @@ dependencies {
   implementation project(':core')
   implementation project(':crypto')
   implementation project(':ssz')
-  implementation project(':util')
+  implementation project(':util:core')
 
   implementation 'com.google.guava:guava'
 
diff --git a/core/build.gradle b/core/build.gradle
index a2172e03a..0870db841 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -1,5 +1,5 @@
 dependencies {
-  implementation project(':types')
+  api project(':types')
   implementation project(':crypto')
   implementation project(':ssz')
 
diff --git a/pow/core/build.gradle b/pow/core/build.gradle
index 39dc5ec10..9ad1c071f 100644
--- a/pow/core/build.gradle
+++ b/pow/core/build.gradle
@@ -3,7 +3,7 @@ dependencies {
   implementation project(':core')
   implementation project(':consensus')
   implementation project(':ssz')
-  implementation project(':util')
+  implementation project(':util:core')
   implementation project(':crypto')
 
   implementation 'io.projectreactor:reactor-core'
diff --git a/pow/ethereumj/build.gradle b/pow/ethereumj/build.gradle
index 01c4f9373..cc1f6d05c 100644
--- a/pow/ethereumj/build.gradle
+++ b/pow/ethereumj/build.gradle
@@ -9,7 +9,7 @@ dependencies {
   implementation project(':types')
   implementation project(':core')
   implementation project(':consensus')
-  implementation project(':util')
+  implementation project(':util:core')
   implementation ("org.ethereum:ethereumj-core") {
     changing = true
 
diff --git a/pow/validator/build.gradle b/pow/validator/build.gradle
index 5faf0b323..7892fe230 100644
--- a/pow/validator/build.gradle
+++ b/pow/validator/build.gradle
@@ -7,7 +7,7 @@ dependencies {
   implementation project(':chain')
   implementation project(':consensus')
   implementation project(':validator')
-  implementation project(':util')
+  implementation project(':util:core')
   implementation project(':db:core')
 
   implementation 'io.projectreactor:reactor-core'
diff --git a/settings.gradle b/settings.gradle
index b83a97b7d..abc6f420e 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -38,7 +38,9 @@ include 'test'
 // Strict types definition
 include 'types'
 // Standalone utils without any relation to Ethereum 2.0
-include 'util'
+include 'util:core'
+// Eth2.0 time utilities
+include 'util:time'
 // Validator services
 include 'validator'
 // Wire API mock
diff --git a/ssz/build.gradle b/ssz/build.gradle
index 37cd933ed..5aea1e8a9 100644
--- a/ssz/build.gradle
+++ b/ssz/build.gradle
@@ -1,9 +1,9 @@
 apply plugin: 'java-library'
 
 dependencies {
-    implementation project(':types')
-    implementation project(':util')
     api 'net.consensys.cava:cava-ssz'
+    implementation project(':types')
+    implementation project(':util:core')
     implementation 'net.consensys.cava:cava-units'
 
     testImplementation 'junit:junit'
diff --git a/start/benchmaker/build.gradle b/start/benchmaker/build.gradle
index b0205a2a9..db8eaac0b 100644
--- a/start/benchmaker/build.gradle
+++ b/start/benchmaker/build.gradle
@@ -10,7 +10,7 @@ application {
 dependencies {
   implementation project(':types')
   implementation project(':wire')
-  implementation project(':util')
+  implementation project(':util:core')
   implementation project(':start:common')
   implementation project(':start:config')
   implementation project(':crypto')
diff --git a/start/common/build.gradle b/start/common/build.gradle
index e83a85628..9d175e8d0 100644
--- a/start/common/build.gradle
+++ b/start/common/build.gradle
@@ -9,7 +9,7 @@ dependencies {
   implementation project(':ssz')
   implementation project(':validator')
   implementation project(':wire')
-  implementation project(':util')
+  implementation project(':util:core')
 
   implementation 'com.google.guava:guava'
   implementation 'io.projectreactor:reactor-core'
diff --git a/start/config/build.gradle b/start/config/build.gradle
index e00e4c370..c539f6d99 100644
--- a/start/config/build.gradle
+++ b/start/config/build.gradle
@@ -3,7 +3,7 @@ dependencies {
   implementation project(':consensus')
   implementation project(':crypto')
   implementation project(':types')
-  implementation project(':util')
+  implementation project(':util:core')
 
   implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml'
   implementation 'com.fasterxml.jackson.core:jackson-databind'
diff --git a/start/node/build.gradle b/start/node/build.gradle
index d6eb5edca..beeadb1b0 100644
--- a/start/node/build.gradle
+++ b/start/node/build.gradle
@@ -10,7 +10,7 @@ application {
 dependencies {
   implementation project(':types')
   implementation project(':wire')
-  implementation project(':util')
+  implementation project(':util:core')
   implementation project(':start:common')
   implementation project(':start:config')
   implementation project(':crypto')
diff --git a/start/simulator/build.gradle b/start/simulator/build.gradle
index 94ee39982..d88a14773 100644
--- a/start/simulator/build.gradle
+++ b/start/simulator/build.gradle
@@ -16,7 +16,7 @@ createScript(project, 'org.ethereum.beacon.simulator.Simulator', 'simulator')
 dependencies {
   implementation project(':types')
   implementation project(':wire')
-  implementation project(':util')
+  implementation project(':util:core')
   implementation project(':start:common')
   implementation project(':start:config')
   implementation project(':crypto')
diff --git a/test/build.gradle b/test/build.gradle
index 38f6ca927..f4ae0cc19 100644
--- a/test/build.gradle
+++ b/test/build.gradle
@@ -11,7 +11,7 @@ dependencies {
   testImplementation project(':db:core')
   testImplementation project(':chain')
   testImplementation project(':start:simulator')
-  testImplementation project(':util')
+  testImplementation project(':util:core')
   testImplementation project(':pow:core')
 }
 
diff --git a/util/build.gradle b/util/build.gradle
index 8549263fa..e69de29bb 100644
--- a/util/build.gradle
+++ b/util/build.gradle
@@ -1,5 +0,0 @@
-dependencies {
-  implementation 'io.projectreactor:reactor-core'
-  implementation 'com.google.guava:guava'
-  implementation 'commons-beanutils:commons-beanutils'
-}
diff --git a/util/core/build.gradle b/util/core/build.gradle
new file mode 100644
index 000000000..8549263fa
--- /dev/null
+++ b/util/core/build.gradle
@@ -0,0 +1,5 @@
+dependencies {
+  implementation 'io.projectreactor:reactor-core'
+  implementation 'com.google.guava:guava'
+  implementation 'commons-beanutils:commons-beanutils'
+}
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/AbstractSchedulers.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/AbstractSchedulers.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/AbstractSchedulers.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/AbstractSchedulers.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/ControlledExecutorService.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/ControlledExecutorService.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/ControlledExecutorService.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/ControlledExecutorService.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/ControlledExecutorServiceImpl.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/ControlledExecutorServiceImpl.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/ControlledExecutorServiceImpl.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/ControlledExecutorServiceImpl.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/ControlledSchedulers.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/ControlledSchedulers.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/ControlledSchedulers.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/ControlledSchedulers.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/ControlledSchedulersImpl.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/ControlledSchedulersImpl.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/ControlledSchedulersImpl.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/ControlledSchedulersImpl.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/DefaultSchedulers.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/DefaultSchedulers.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/DefaultSchedulers.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/DefaultSchedulers.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/DelegatingReactorScheduler.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/DelegatingReactorScheduler.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/DelegatingReactorScheduler.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/DelegatingReactorScheduler.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/ErrorHandlingScheduler.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/ErrorHandlingScheduler.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/ErrorHandlingScheduler.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/ErrorHandlingScheduler.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/ExecutorScheduler.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/ExecutorScheduler.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/ExecutorScheduler.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/ExecutorScheduler.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/LatestExecutor.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/LatestExecutor.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/LatestExecutor.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/LatestExecutor.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/LoggerMDCExecutor.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/LoggerMDCExecutor.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/LoggerMDCExecutor.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/LoggerMDCExecutor.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/RunnableEx.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/RunnableEx.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/RunnableEx.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/RunnableEx.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/Scheduler.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/Scheduler.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/Scheduler.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/Scheduler.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/Schedulers.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/Schedulers.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/Schedulers.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/Schedulers.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/TimeController.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/TimeController.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/TimeController.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/TimeController.java
diff --git a/util/src/main/java/org/ethereum/beacon/schedulers/TimeControllerImpl.java b/util/core/src/main/java/org/ethereum/beacon/schedulers/TimeControllerImpl.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/schedulers/TimeControllerImpl.java
rename to util/core/src/main/java/org/ethereum/beacon/schedulers/TimeControllerImpl.java
diff --git a/util/src/main/java/org/ethereum/beacon/stream/RxUtil.java b/util/core/src/main/java/org/ethereum/beacon/stream/RxUtil.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/stream/RxUtil.java
rename to util/core/src/main/java/org/ethereum/beacon/stream/RxUtil.java
diff --git a/util/src/main/java/org/ethereum/beacon/stream/SimpleProcessor.java b/util/core/src/main/java/org/ethereum/beacon/stream/SimpleProcessor.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/stream/SimpleProcessor.java
rename to util/core/src/main/java/org/ethereum/beacon/stream/SimpleProcessor.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/ConsumerList.java b/util/core/src/main/java/org/ethereum/beacon/util/ConsumerList.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/ConsumerList.java
rename to util/core/src/main/java/org/ethereum/beacon/util/ConsumerList.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/Objects.java b/util/core/src/main/java/org/ethereum/beacon/util/Objects.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/Objects.java
rename to util/core/src/main/java/org/ethereum/beacon/util/Objects.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/Utils.java b/util/core/src/main/java/org/ethereum/beacon/util/Utils.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/Utils.java
rename to util/core/src/main/java/org/ethereum/beacon/util/Utils.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/cache/Cache.java b/util/core/src/main/java/org/ethereum/beacon/util/cache/Cache.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/cache/Cache.java
rename to util/core/src/main/java/org/ethereum/beacon/util/cache/Cache.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/cache/CacheFactory.java b/util/core/src/main/java/org/ethereum/beacon/util/cache/CacheFactory.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/cache/CacheFactory.java
rename to util/core/src/main/java/org/ethereum/beacon/util/cache/CacheFactory.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/cache/DebugCacheFactory.java b/util/core/src/main/java/org/ethereum/beacon/util/cache/DebugCacheFactory.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/cache/DebugCacheFactory.java
rename to util/core/src/main/java/org/ethereum/beacon/util/cache/DebugCacheFactory.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/cache/LRUCache.java b/util/core/src/main/java/org/ethereum/beacon/util/cache/LRUCache.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/cache/LRUCache.java
rename to util/core/src/main/java/org/ethereum/beacon/util/cache/LRUCache.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/cache/MockCache.java b/util/core/src/main/java/org/ethereum/beacon/util/cache/MockCache.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/cache/MockCache.java
rename to util/core/src/main/java/org/ethereum/beacon/util/cache/MockCache.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/cache/NoCacheFactory.java b/util/core/src/main/java/org/ethereum/beacon/util/cache/NoCacheFactory.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/cache/NoCacheFactory.java
rename to util/core/src/main/java/org/ethereum/beacon/util/cache/NoCacheFactory.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/cache/RegularCacheFactory.java b/util/core/src/main/java/org/ethereum/beacon/util/cache/RegularCacheFactory.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/cache/RegularCacheFactory.java
rename to util/core/src/main/java/org/ethereum/beacon/util/cache/RegularCacheFactory.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/stats/MeasurementsCollector.java b/util/core/src/main/java/org/ethereum/beacon/util/stats/MeasurementsCollector.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/stats/MeasurementsCollector.java
rename to util/core/src/main/java/org/ethereum/beacon/util/stats/MeasurementsCollector.java
diff --git a/util/src/main/java/org/ethereum/beacon/util/stats/TimeCollector.java b/util/core/src/main/java/org/ethereum/beacon/util/stats/TimeCollector.java
similarity index 100%
rename from util/src/main/java/org/ethereum/beacon/util/stats/TimeCollector.java
rename to util/core/src/main/java/org/ethereum/beacon/util/stats/TimeCollector.java
diff --git a/util/src/test/java/org/ethereum/beacon/schedulers/ControlledExecutorServiceTest.java b/util/core/src/test/java/org/ethereum/beacon/schedulers/ControlledExecutorServiceTest.java
similarity index 100%
rename from util/src/test/java/org/ethereum/beacon/schedulers/ControlledExecutorServiceTest.java
rename to util/core/src/test/java/org/ethereum/beacon/schedulers/ControlledExecutorServiceTest.java
diff --git a/util/src/test/java/org/ethereum/beacon/schedulers/ControlledSchedulersTest.java b/util/core/src/test/java/org/ethereum/beacon/schedulers/ControlledSchedulersTest.java
similarity index 100%
rename from util/src/test/java/org/ethereum/beacon/schedulers/ControlledSchedulersTest.java
rename to util/core/src/test/java/org/ethereum/beacon/schedulers/ControlledSchedulersTest.java
diff --git a/util/src/test/java/org/ethereum/beacon/schedulers/LatestExecutorTest.java b/util/core/src/test/java/org/ethereum/beacon/schedulers/LatestExecutorTest.java
similarity index 100%
rename from util/src/test/java/org/ethereum/beacon/schedulers/LatestExecutorTest.java
rename to util/core/src/test/java/org/ethereum/beacon/schedulers/LatestExecutorTest.java
diff --git a/util/src/test/java/org/ethereum/beacon/util/ConsumerListTest.java b/util/core/src/test/java/org/ethereum/beacon/util/ConsumerListTest.java
similarity index 100%
rename from util/src/test/java/org/ethereum/beacon/util/ConsumerListTest.java
rename to util/core/src/test/java/org/ethereum/beacon/util/ConsumerListTest.java
diff --git a/util/time/build.gradle b/util/time/build.gradle
new file mode 100644
index 000000000..a1d59802a
--- /dev/null
+++ b/util/time/build.gradle
@@ -0,0 +1,12 @@
+dependencies {
+  implementation project(':util:core')
+  implementation project(':core')
+
+  implementation 'io.projectreactor:reactor-core'
+  implementation 'commons-net:commons-net'
+  implementation 'org.apache.logging.log4j:log4j-core'
+
+  testImplementation project(':consensus')
+  testImplementation project(':ssz')
+  testImplementation 'junit:junit'
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/NetworkFirstStrategy.java b/util/time/src/main/java/org/ethereum/beacon/time/NetworkFirstStrategy.java
new file mode 100644
index 000000000..312599525
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/NetworkFirstStrategy.java
@@ -0,0 +1,60 @@
+package org.ethereum.beacon.time;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.schedulers.Scheduler;
+import org.ethereum.beacon.stream.SimpleProcessor;
+import org.ethereum.beacon.time.provider.NetworkTime;
+import org.ethereum.beacon.time.provider.StatisticsTime;
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Strategy which prioritize {@link NetworkTime} but if the delta between {@link NetworkTime} and
+ * {@link StatisticsTime} goes above allowedDelta, it uses {@link StatisticsTime} as time provider.
+ */
+public class NetworkFirstStrategy implements TimeStrategy {
+  private final SimpleProcessor<Time> timeProcessor;
+  private final AtomicLong latestNetwork = new AtomicLong(-1);
+  private final AtomicLong latestStatistics = new AtomicLong(-1);
+  private static final Logger logger = LogManager.getLogger("time");
+
+  public NetworkFirstStrategy(
+      Scheduler scheduler,
+      NetworkTime networkTime,
+      StatisticsTime statisticsTime,
+      int allowedDelta) {
+    this.timeProcessor = new SimpleProcessor<Time>(scheduler, "NetworkFirstStrategy");
+    Flux.from(networkTime.getTimeStream())
+        .subscribe(
+            t -> {
+              this.latestNetwork.set(t.getValue());
+              if (latestStatistics.get() == -1) {
+                return;
+              }
+              if (Math.abs(latestNetwork.get() - latestStatistics.get()) <= allowedDelta) {
+                timeProcessor.onNext(t);
+              }
+            });
+    Flux.from(statisticsTime.getTimeStream())
+        .subscribe(
+            t -> {
+              this.latestStatistics.set(t.getValue());
+              if (latestNetwork.get() == -1) {
+                return;
+              }
+              if (Math.abs(latestNetwork.get() - latestStatistics.get()) > allowedDelta) {
+                logger.trace(() -> String.format("Using time from statistics time provider: %s", t.getValue()));
+                timeProcessor.onNext(t);
+              }
+            });
+  }
+
+  @Override
+  public Publisher<Time> getTimeStream() {
+    return timeProcessor;
+  }
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/StatisticsStrategy.java b/util/time/src/main/java/org/ethereum/beacon/time/StatisticsStrategy.java
new file mode 100644
index 000000000..79ce77b73
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/StatisticsStrategy.java
@@ -0,0 +1,18 @@
+package org.ethereum.beacon.time;
+
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.time.provider.StatisticsTime;
+import org.reactivestreams.Publisher;
+
+public class StatisticsStrategy implements TimeStrategy {
+  private final StatisticsTime statisticsTime;
+
+  public StatisticsStrategy(StatisticsTime statisticsTime) {
+    this.statisticsTime = statisticsTime;
+  }
+
+  @Override
+  public Publisher<Time> getTimeStream() {
+    return statisticsTime.getTimeStream();
+  }
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/TimeStrategy.java b/util/time/src/main/java/org/ethereum/beacon/time/TimeStrategy.java
new file mode 100644
index 000000000..7208ac8c5
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/TimeStrategy.java
@@ -0,0 +1,12 @@
+package org.ethereum.beacon.time;
+
+import org.ethereum.beacon.core.types.Time;
+import org.reactivestreams.Publisher;
+
+/**
+ * High level time supplier, uses several {@link org.ethereum.beacon.time.provider.TimeProvider} to
+ * produce result time
+ */
+public interface TimeStrategy {
+  Publisher<Time> getTimeStream();
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/mapper/ObjectTimeMapper.java b/util/time/src/main/java/org/ethereum/beacon/time/mapper/ObjectTimeMapper.java
new file mode 100644
index 000000000..aebe76834
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/mapper/ObjectTimeMapper.java
@@ -0,0 +1,30 @@
+package org.ethereum.beacon.time.mapper;
+
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.schedulers.Scheduler;
+import org.ethereum.beacon.stream.SimpleProcessor;
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+
+import java.util.function.Function;
+
+public class ObjectTimeMapper<T> implements TimeMapper {
+  private final Function<T, Time> timeFunc;
+  private final SimpleProcessor<Time> timeProcessor;
+
+  public ObjectTimeMapper(
+      Scheduler scheduler, Publisher<T> objectStream, Function<T, Time> timeFunc) {
+    this.timeProcessor = new SimpleProcessor<>(scheduler, "TimeMapper");
+    this.timeFunc = timeFunc;
+    Flux.from(objectStream).map(this::mapObjectFunc).subscribe(timeProcessor::onNext);
+  }
+
+  Time mapObjectFunc(T obj) {
+    return timeFunc.apply(obj);
+  }
+
+  @Override
+  public Publisher<Time> getTimeStream() {
+    return timeProcessor;
+  }
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/mapper/TimeMapper.java b/util/time/src/main/java/org/ethereum/beacon/time/mapper/TimeMapper.java
new file mode 100644
index 000000000..eb1d6362f
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/mapper/TimeMapper.java
@@ -0,0 +1,9 @@
+package org.ethereum.beacon.time.mapper;
+
+import org.ethereum.beacon.core.types.Time;
+import org.reactivestreams.Publisher;
+
+/** Maps stream of objects with some kind of time info to time stream */
+public interface TimeMapper {
+  Publisher<Time> getTimeStream();
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/provider/NetworkTime.java b/util/time/src/main/java/org/ethereum/beacon/time/provider/NetworkTime.java
new file mode 100644
index 000000000..8d9467aa1
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/provider/NetworkTime.java
@@ -0,0 +1,134 @@
+package org.ethereum.beacon.time.provider;
+
+import org.apache.commons.net.ntp.NTPUDPClient;
+import org.apache.commons.net.ntp.TimeInfo;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.schedulers.Scheduler;
+import org.ethereum.beacon.stream.SimpleProcessor;
+import org.reactivestreams.Publisher;
+
+import java.net.InetAddress;
+import java.security.SecureRandom;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.temporal.ChronoField;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+/** Time provider using NTP servers to correct time every defined period */
+public class NetworkTime implements TimeProvider {
+  private static final int MILLIS_IN_SEC = 1000;
+  private static final int DOUBLE_CHECK_DIFF = 5 * MILLIS_IN_SEC;
+  private static final Logger logger = LogManager.getLogger("time");
+
+  private final SimpleProcessor<Time> timeProcessor;
+  private final List<String> ntpServers;
+  private final SecureRandom random = new SecureRandom();
+  private final AtomicLong latest = new AtomicLong(-1);
+  private final AtomicLong offset = new AtomicLong(0);
+  private String latestServer = "";
+
+  public NetworkTime(
+      Scheduler events,
+      Scheduler worker,
+      Scheduler networkWorker,
+      List<String> ntpServers,
+      long correctionPeriodMs) {
+    this.ntpServers = ntpServers;
+    this.timeProcessor = new SimpleProcessor<Time>(events, "TimeProvider.network");
+    worker.executeR(
+        () -> {
+          while (!Thread.currentThread().isInterrupted()) {
+            emitTime();
+          }
+        });
+    networkWorker.executeAtFixedRate(
+        Duration.ZERO, Duration.ofMillis(correctionPeriodMs), this::updateOffset);
+  }
+
+  private void updateOffset() {
+    try {
+      String server = getNextServer(latestServer);
+      long newOffset = pullOffset(server);
+      // If we get big difference - recheck
+      if (Math.abs(newOffset - offset.get()) > DOUBLE_CHECK_DIFF && !latestServer.isEmpty()) {
+        final String finalServer = server;
+        final long finalNewOffset = newOffset;
+        logger.warn(
+            String.format(
+                "Offset from previous NTP server `%s`(%s) was changed above threshold(%s ms) according to data from "
+                    + "NTP server `%s`(%s). Retrying request with new server",
+                latestServer, offset.get(), DOUBLE_CHECK_DIFF, finalServer, finalNewOffset));
+        server = getNextServer(server);
+        newOffset = pullOffset(server);
+      }
+      this.latestServer = server;
+
+      // Reset latest if offset has changed dramatically to reset emitting
+      if (Math.abs(newOffset - offset.get()) > MILLIS_IN_SEC) {
+        latest.set(-1);
+      }
+      offset.set(newOffset);
+      logger.trace(
+          () ->
+              String.format(
+                  "Offset set to %s using data from NTP server `%s`", offset, latestServer));
+    } catch (Exception e) {
+      logger.error("Failed to update offset", e);
+    }
+  }
+
+  /** Clock offset in ms needed to adjust local clock to match remote clock */
+  long pullOffset(String serverHost) {
+    logger.trace(() -> String.format("Requesting time offset from NTP server `%s`", serverHost));
+    try {
+      NTPUDPClient timeClient = new NTPUDPClient();
+      InetAddress inetAddress = InetAddress.getByName(serverHost);
+      TimeInfo timeInfo = timeClient.getTime(inetAddress);
+      timeInfo.computeDetails();
+      logger.trace(
+          () ->
+              String.format(
+                  "Received time offset from NTP server `%s`: %s",
+                  serverHost, timeInfo.getOffset()));
+      return timeInfo.getOffset();
+    } catch (Exception ex) {
+      logger.debug(() -> String.format("Failed to get offset from NTP server `%s`", serverHost));
+      throw new RuntimeException(
+          String.format("Failed to get time from server %s", serverHost), ex);
+    }
+  }
+
+  private String getNextServer(String filter) {
+    List<String> remaining =
+        ntpServers.stream().filter(s -> !s.equals(filter)).collect(Collectors.toList());
+    if (remaining.isEmpty()) {
+      remaining = ntpServers;
+    }
+
+    return remaining.get(random.nextInt(remaining.size()));
+  }
+
+  private void emitTime() {
+    Instant nowCorrected = Instant.now().plusMillis(offset.get());
+    long currentSec = nowCorrected.getEpochSecond();
+    long currentMs = nowCorrected.getLong(ChronoField.MILLI_OF_SECOND);
+    if (currentSec > latest.get()) {
+      timeProcessor.onNext(Time.of(currentSec));
+      latest.set(currentSec);
+    }
+    try {
+      Thread.sleep(MILLIS_IN_SEC - currentMs);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+    }
+  }
+
+  @Override
+  public Publisher<Time> getTimeStream() {
+    return timeProcessor;
+  }
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/provider/StatisticsTime.java b/util/time/src/main/java/org/ethereum/beacon/time/provider/StatisticsTime.java
new file mode 100644
index 000000000..989d57954
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/provider/StatisticsTime.java
@@ -0,0 +1,116 @@
+package org.ethereum.beacon.time.provider;
+
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.schedulers.Scheduler;
+import org.ethereum.beacon.stream.SimpleProcessor;
+import org.javatuples.Pair;
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Time provider uses statistics from ethereum network objects
+ *
+ * <p>Keeps statistics for latest secondsBuffer seconds, calculates offsets to systemTime on this
+ * sample of data, uses {@link #offsetAggregator(Map)} to get the best single offset value and adds
+ * it to system time to provide output value
+ *
+ * <p>See <a
+ * href="https://ethresear.ch/t/network-adjusted-timestamps/4187">https://ethresear.ch/t/network-adjusted-timestamps/4187</a>
+ */
+public class StatisticsTime implements TimeProvider {
+  private final SimpleProcessor<Time> timeProcessor;
+  private final Map<Long, Map<Long, AtomicInteger>> data = new HashMap<>();
+  private final AtomicLong latestSystem = new AtomicLong(-1);
+  private final AtomicInteger offset = new AtomicInteger(0);
+
+  @SafeVarargs
+  public StatisticsTime(
+      Scheduler events,
+      Scheduler worker,
+      int secondsBuffer,
+      int filterOutliers,
+      Publisher<Time>... objectTimeStreams) {
+    this.timeProcessor = new SimpleProcessor<Time>(events, "TimeProvider.statistics");
+    SystemTime systemTime = new SystemTime(events, worker);
+    Flux.from(systemTime.getTimeStream())
+        .subscribe(
+            time -> {
+              Map<Integer, Integer> offsets = gatherDataIntoOffsets(filterOutliers);
+              long newOffset = offsetAggregator(offsets);
+              offset.set((int) newOffset);
+              data.remove(time.getValue() - secondsBuffer);
+              latestSystem.set(time.getValue());
+              timeProcessor.onNext(Time.of(time.getValue() + newOffset));
+              data.put(time.getValue(), new HashMap<>());
+            });
+    Flux.concat(objectTimeStreams)
+        .subscribe(
+            time -> {
+              Map<Long, AtomicInteger> latestStat = data.get(latestSystem.get());
+              if (latestStat.containsKey(time.getValue())) {
+                latestStat.get(time.getValue()).incrementAndGet();
+              } else {
+                latestStat.put(time.getValue(), new AtomicInteger(1));
+              }
+            });
+  }
+
+  private Map<Integer, Integer> gatherDataIntoOffsets(int filterOutliers) {
+    return data.entrySet().stream()
+        // => stream(offset: counter)
+        .flatMap(
+            (Function<Map.Entry<Long, Map<Long, AtomicInteger>>, Stream<Pair<Integer, Integer>>>)
+                longMapEntry -> {
+                  long systemTime1 = longMapEntry.getKey();
+                  List<Pair<Integer, Integer>> offsetCounters = new ArrayList<>();
+                  for (Map.Entry<Long, AtomicInteger> entry : longMapEntry.getValue().entrySet()) {
+                    offsetCounters.add(
+                        Pair.with((int) (systemTime1 - entry.getKey()), entry.getValue().get()));
+                  }
+                  return offsetCounters.stream();
+                })
+        .collect( // offset -> sum of counters
+            Collectors.groupingBy(Pair::getValue0, Collectors.summarizingInt(Pair::getValue1)))
+        .entrySet()
+        .stream()
+        // filter outliers
+        .filter(e -> e.getValue().getSum() > filterOutliers)
+        .map(e -> Pair.with(e.getKey(), Math.toIntExact(e.getValue().getSum())))
+        .collect(Collectors.toMap(Pair::getValue0, Pair::getValue1));
+  }
+
+  /**
+   * Taking into account offset statistics: [offset: count] provides estimated single number offset
+   * with such kind of input by applying some statistic aggregation function (depends on
+   * implementation)
+   */
+  Integer offsetAggregator(Map<Integer, Integer> data) {
+    // Median calculation
+    List<Integer> offsets = new ArrayList<>(data.keySet());
+    if (offsets.isEmpty()) {
+      return 0;
+    }
+    offsets.sort(Integer::compareTo);
+    int middle = offsets.size() / 2;
+    if (offsets.size() % 2 == 0) {
+      return (offsets.get(middle) + offsets.get(middle - 1)) / 2;
+    } else {
+      return offsets.get(middle);
+    }
+  }
+
+  @Override
+  public Publisher<Time> getTimeStream() {
+    return timeProcessor;
+  }
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/provider/SystemTime.java b/util/time/src/main/java/org/ethereum/beacon/time/provider/SystemTime.java
new file mode 100644
index 000000000..9c565e673
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/provider/SystemTime.java
@@ -0,0 +1,49 @@
+package org.ethereum.beacon.time.provider;
+
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.schedulers.Scheduler;
+import org.ethereum.beacon.stream.SimpleProcessor;
+import org.reactivestreams.Publisher;
+
+import java.time.Instant;
+import java.time.temporal.ChronoField;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Time Provider uses system time
+ */
+public class SystemTime implements TimeProvider {
+  private static final int MILLIS_IN_SEC = 1000;
+  private final SimpleProcessor<Time> timeProcessor;
+  private final AtomicLong latest = new AtomicLong(-1);
+
+  public SystemTime(Scheduler events, Scheduler worker) {
+    this.timeProcessor = new SimpleProcessor<Time>(events, "TimeProvider.system");
+    worker.executeR(
+        () -> {
+          while (!Thread.currentThread().isInterrupted()) {
+            emitTime();
+          }
+        });
+  }
+
+  private void emitTime() {
+    long currentSec = Instant.now().getEpochSecond();
+    if (currentSec > latest.get()) {
+      System.out.println("Time: " + currentSec);
+      timeProcessor.onNext(Time.of(currentSec));
+      latest.set(currentSec);
+    }
+    long currentMs = Instant.now().getLong(ChronoField.MILLI_OF_SECOND);
+    try {
+      Thread.sleep(MILLIS_IN_SEC - currentMs);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+    }
+  }
+
+  @Override
+  public Publisher<Time> getTimeStream() {
+    return timeProcessor;
+  }
+}
diff --git a/util/time/src/main/java/org/ethereum/beacon/time/provider/TimeProvider.java b/util/time/src/main/java/org/ethereum/beacon/time/provider/TimeProvider.java
new file mode 100644
index 000000000..ca8840bad
--- /dev/null
+++ b/util/time/src/main/java/org/ethereum/beacon/time/provider/TimeProvider.java
@@ -0,0 +1,11 @@
+package org.ethereum.beacon.time.provider;
+
+import org.ethereum.beacon.core.types.Time;
+import org.reactivestreams.Publisher;
+
+/**
+ * Supplier of Time ticks
+ */
+public interface TimeProvider {
+  Publisher<Time> getTimeStream();
+}
diff --git a/util/time/src/test/java/org/ethereum/beacon/time/mapper/ObjectTimeMapperTest.java b/util/time/src/test/java/org/ethereum/beacon/time/mapper/ObjectTimeMapperTest.java
new file mode 100644
index 000000000..169042536
--- /dev/null
+++ b/util/time/src/test/java/org/ethereum/beacon/time/mapper/ObjectTimeMapperTest.java
@@ -0,0 +1,84 @@
+package org.ethereum.beacon.time.mapper;
+
+import org.ethereum.beacon.consensus.BeaconChainSpec;
+import org.ethereum.beacon.core.BeaconBlock;
+import org.ethereum.beacon.core.BeaconBlockBody;
+import org.ethereum.beacon.core.BeaconState;
+import org.ethereum.beacon.core.MutableBeaconState;
+import org.ethereum.beacon.core.spec.SpecConstants;
+import org.ethereum.beacon.core.types.BLSSignature;
+import org.ethereum.beacon.core.types.SlotNumber;
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.schedulers.Schedulers;
+import org.ethereum.beacon.stream.SimpleProcessor;
+import org.junit.Test;
+import reactor.core.publisher.Flux;
+import tech.pegasys.artemis.ethereum.core.Hash32;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.stream.LongStream;
+
+public class ObjectTimeMapperTest {
+
+  @Test
+  public void testBlock() {
+    BeaconChainSpec spec =
+        BeaconChainSpec.createWithDefaultHasher(
+            new SpecConstants() {
+              @Override
+              public SlotNumber getGenesisSlot() {
+                return SlotNumber.ZERO;
+              }
+
+              @Override
+              public Time getSecondsPerSlot() {
+                return Time.of(1);
+              }
+            });
+    MutableBeaconState state = BeaconState.getEmpty().createMutableCopy();
+    long startTime = 1000;
+    state.setGenesisTime(Time.of(startTime));
+    SimpleProcessor<BeaconBlock> blockStream =
+        new SimpleProcessor<>(Schedulers.createDefault().events(), "test");
+
+    ObjectTimeMapper<BeaconBlock> blockMapper =
+        new ObjectTimeMapper<>(
+            Schedulers.createDefault().events(),
+            blockStream,
+            block -> spec.get_slot_start_time(state, block.getSlot()));
+
+    CountDownLatch getFive = new CountDownLatch(5);
+    Flux.from(blockMapper.getTimeStream())
+        .subscribe(
+            new Consumer<Time>() {
+              private int counter = 0;
+
+              @Override
+              public void accept(Time time) {
+                if (time.getValue() == (startTime + counter)) {
+                  getFive.countDown();
+                  ++counter;
+                }
+              }
+            });
+
+    LongStream.range(0, 5).mapToObj((long slot) -> createBlockWithSlot(slot, spec.getConstants())).forEach(blockStream::onNext);
+    try {
+      assert getFive.await(100, TimeUnit.MILLISECONDS);
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+  }
+
+  private BeaconBlock createBlockWithSlot(long slot, SpecConstants constants) {
+    return BeaconBlock.Builder.createEmpty()
+        .withBody(BeaconBlockBody.getEmpty(constants))
+        .withParentRoot(Hash32.ZERO)
+        .withSignature(BLSSignature.ZERO)
+        .withStateRoot(Hash32.ZERO)
+        .withSlot(SlotNumber.of(slot))
+        .build();
+  }
+}
diff --git a/util/time/src/test/java/org/ethereum/beacon/time/provider/NetworkTimeTest.java b/util/time/src/test/java/org/ethereum/beacon/time/provider/NetworkTimeTest.java
new file mode 100644
index 000000000..1590ea0f5
--- /dev/null
+++ b/util/time/src/test/java/org/ethereum/beacon/time/provider/NetworkTimeTest.java
@@ -0,0 +1,178 @@
+package org.ethereum.beacon.time.provider;
+
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.schedulers.Schedulers;
+import org.junit.Ignore;
+import org.junit.Test;
+import reactor.core.Disposable;
+import reactor.core.publisher.Flux;
+
+import java.time.Instant;
+import java.time.temporal.ChronoField;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+@Ignore("30 seconds test")
+public class NetworkTimeTest {
+  private static final int CORRECTION_PERIOD_MS = 5500;
+  private List<String> ntpServers = new ArrayList<String>() {{
+    add("pool.ntp.org");
+  }};
+
+  @Test
+  public void testNegativeOffset() {
+    Schedulers schedulers = Schedulers.createDefault();
+    TimeProvider provider =
+        new NetworkTime(
+            schedulers.events(),
+            schedulers.newSingleThreadDaemon("system-time"),
+            schedulers.newSingleThreadDaemon("network-time"),
+            ntpServers,
+            CORRECTION_PERIOD_MS) {
+          private int currentQuery = 0;
+
+          @Override
+          long pullOffset(String serverHost) {
+            long ret;
+            if (currentQuery == 0) {
+              ret = -500; // moved to previous second
+            } else {
+              ret = -1500; // 1500 total, so only one time is delayed
+            }
+
+            ++currentQuery;
+            return ret;
+          }
+        };
+
+    // Move to XXX.050 second so we will not have any issues with start on .999 or .001
+    long smartDelay = 1000 - Instant.now().getLong(ChronoField.MILLI_OF_SECOND) + 50;
+    try {
+      Thread.sleep(smartDelay);
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+
+    long start = Instant.now().getEpochSecond();
+    List<Time> res = new ArrayList<>();
+    Disposable subscription = Flux.from((provider.getTimeStream())).subscribe(res::add);
+
+    // We are getting first one immediately, so need 9 more to get 9 in total
+    while (Instant.now().getEpochSecond() < (start + 9)) {
+      try {
+        Thread.sleep(100);
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+    }
+    subscription.dispose();
+
+    assertEquals(9, res.size());
+    for (int i = 0; i < 9; ++i) {
+      assertEquals(start + i - 1, res.get(i).longValue());
+    }
+  }
+
+  @Test
+  public void testBigNegativeOffset() {
+    Schedulers schedulers = Schedulers.createDefault();
+    TimeProvider provider =
+        new NetworkTime(
+            schedulers.events(),
+            schedulers.newSingleThreadDaemon("system-time"),
+            schedulers.newSingleThreadDaemon("network-time"),
+            ntpServers,
+            CORRECTION_PERIOD_MS) {
+          @Override
+          long pullOffset(String serverHost) {
+            return -4500;
+          }
+        };
+
+    // Move to XXX.050 second so we will not have any issues with start on .999 or .001
+    long smartDelay = 1000 - Instant.now().getLong(ChronoField.MILLI_OF_SECOND) + 50;
+    try {
+      Thread.sleep(smartDelay);
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+
+    long start = Instant.now().getEpochSecond();
+    List<Time> res = new ArrayList<>();
+    Disposable subscription = Flux.from((provider.getTimeStream())).subscribe(res::add);
+
+    // We are getting first one immediately, so we are getting 9 in total after 9 seconds
+    while (Instant.now().getEpochSecond() < (start + 9)) {
+      try {
+        Thread.sleep(100);
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+    }
+    subscription.dispose();
+
+    assertEquals(10, res.size());
+    for (int i = 0; i < 10; ++i) {
+      assertEquals(start + i - 5, res.get(i).longValue());
+    }
+  }
+
+  @Test
+  public void testNegativePositiveOffset() {
+    Schedulers schedulers = Schedulers.createDefault();
+    TimeProvider provider =
+        new NetworkTime(
+            schedulers.events(),
+            schedulers.newSingleThreadDaemon("system-time"),
+            schedulers.newSingleThreadDaemon("network-time"),
+            ntpServers,
+            CORRECTION_PERIOD_MS) {
+          private int currentQuery = 0;
+
+          @Override
+          long pullOffset(String serverHost) {
+            long ret;
+            if (currentQuery == 0) {
+              ret = 1500; // effective immediately
+            } else {
+              ret = -1500; // so total -3 seconds backwards after the middle
+            }
+
+            ++currentQuery;
+            return ret;
+          }
+        };
+
+    // Move to XXX.050 second so we will not have any issues with start on .999 or .001
+    long smartDelay = 1000 - Instant.now().getLong(ChronoField.MILLI_OF_SECOND) + 50;
+    try {
+      Thread.sleep(smartDelay);
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+
+    long start = Instant.now().getEpochSecond();
+    List<Time> res = new ArrayList<>();
+    Disposable subscription = Flux.from((provider.getTimeStream())).subscribe(res::add);
+
+    // We are getting first one immediately, so need 9 more to get 10 in total
+    while (Instant.now().getEpochSecond() < (start + 9)) {
+      try {
+        Thread.sleep(100);
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+    }
+    subscription.dispose();
+
+    assertEquals(10, res.size());
+    for (int i = 0; i < 6; ++i) {
+      assertEquals(start + i + 1, res.get(i).longValue());
+    }
+    for (int i = 6; i < 10; ++i) { // + 1 -> - 2, 3 seconds difference
+      assertEquals(start + i - 2, res.get(i).longValue());
+    }
+  }
+}
diff --git a/util/time/src/test/java/org/ethereum/beacon/time/provider/TimeProviderTest.java b/util/time/src/test/java/org/ethereum/beacon/time/provider/TimeProviderTest.java
new file mode 100644
index 000000000..f3dc4288b
--- /dev/null
+++ b/util/time/src/test/java/org/ethereum/beacon/time/provider/TimeProviderTest.java
@@ -0,0 +1,144 @@
+package org.ethereum.beacon.time.provider;
+
+import org.ethereum.beacon.core.types.Time;
+import org.ethereum.beacon.schedulers.Schedulers;
+import org.javatuples.Pair;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.reactivestreams.Publisher;
+import reactor.core.Disposable;
+import reactor.core.publisher.Flux;
+
+import java.time.Instant;
+import java.time.temporal.ChronoField;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+@Ignore("10 seconds test")
+public class TimeProviderTest {
+  private static final int CORRECTION_PERIOD_MS = 5500;
+  private List<String> ntpServers =
+      new ArrayList<String>() {
+        {
+          add("pool.ntp.org");
+        }
+      };
+
+  @Test
+  public void testSystem() {
+    TimeProvider provider =
+        new SystemTime(
+            Schedulers.createDefault().events(),
+            Schedulers.createDefault().newSingleThreadDaemon("system-time"));
+    standardTester(provider);
+  }
+
+  @Ignore("10 seconds test")
+  @Test
+  public void testNetwork() {
+    Schedulers schedulers = Schedulers.createDefault();
+    TimeProvider provider =
+        new NetworkTime(
+            schedulers.events(),
+            schedulers.newSingleThreadDaemon("system-time"),
+            schedulers.newSingleThreadDaemon("network-time"),
+            ntpServers,
+            CORRECTION_PERIOD_MS);
+    standardTester(provider);
+  }
+
+  @Test
+  @Ignore("TODO: FIXME!!!!!")
+  public void testStatistics() {
+    Schedulers schedulers = Schedulers.createDefault();
+    List<Publisher<Time>> objectTimeStreams = new ArrayList<>();
+    TimeProvider provider1 =
+        new NetworkTime(
+            schedulers.events(),
+            schedulers.newSingleThreadDaemon("system-time"),
+            schedulers.newSingleThreadDaemon("network-time"),
+            ntpServers,
+            CORRECTION_PERIOD_MS) {
+          @Override
+          long pullOffset(String serverHost) {
+            return 1000;
+          }
+        };
+    objectTimeStreams.add(provider1.getTimeStream());
+    TimeProvider provider2 =
+        new NetworkTime(
+            schedulers.events(),
+            schedulers.newSingleThreadDaemon("system-time"),
+            schedulers.newSingleThreadDaemon("network-time"),
+            ntpServers,
+            CORRECTION_PERIOD_MS) {
+          @Override
+          long pullOffset(String serverHost) {
+            return 4000;
+          }
+        };
+    objectTimeStreams.add(provider2.getTimeStream());
+    TimeProvider provider3 =
+        new NetworkTime(
+            schedulers.events(),
+            schedulers.newSingleThreadDaemon("system-time"),
+            schedulers.newSingleThreadDaemon("network-time"),
+            ntpServers,
+            CORRECTION_PERIOD_MS) {
+          @Override
+          long pullOffset(String serverHost) {
+            return 5000;
+          }
+        };
+    objectTimeStreams.add(provider3.getTimeStream());
+
+    TimeProvider provider =
+        new StatisticsTime(
+            schedulers.events(),
+            schedulers.newSingleThreadDaemon("system-time"),
+            5,
+            0,
+            (Publisher<Time>[]) objectTimeStreams.toArray(new Publisher[0]));
+    Pair<Long, List<Time>> res = gatherTimeObjects(provider);
+    assertEquals(10, res.getValue1().size());
+    for (int i = 0; i < 10; ++i) {
+      assertEquals(res.getValue0() + i, res.getValue1().get(i).longValue());
+    }
+  }
+
+  private void standardTester(TimeProvider provider) {
+    Pair<Long, List<Time>> res = gatherTimeObjects(provider);
+    assertEquals(10, res.getValue1().size());
+    for (int i = 0; i < 10; ++i) {
+      assertEquals(res.getValue0() + i, res.getValue1().get(i).longValue());
+    }
+  }
+
+  private Pair<Long, List<Time>> gatherTimeObjects(TimeProvider provider) {
+    // Move to XXX.050 second so we will not have any issues with start on .999 or .001
+    long smartDelay = 1000 - Instant.now().getLong(ChronoField.MILLI_OF_SECOND) + 50;
+    try {
+      Thread.sleep(smartDelay);
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+
+    long start = Instant.now().getEpochSecond();
+    List<Time> res = new ArrayList<>();
+    Disposable subscription = Flux.from((provider.getTimeStream())).subscribe(res::add);
+
+    // We are getting first one immediately, so need 9 more to get 10 in total
+    while (Instant.now().getEpochSecond() < (start + 9)) {
+      try {
+        Thread.sleep(100);
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+    }
+    subscription.dispose();
+
+    return Pair.with(start, res);
+  }
+}
diff --git a/validator/build.gradle b/validator/build.gradle
index a48d38bf1..a38fa84ac 100644
--- a/validator/build.gradle
+++ b/validator/build.gradle
@@ -7,7 +7,7 @@ dependencies {
   implementation project(':chain')
   implementation project(':pow:core')
   implementation project(':ssz')
-  implementation project(':util')
+  implementation project(':util:core')
 
   implementation 'com.google.guava:guava'
   implementation 'io.projectreactor:reactor-core'
diff --git a/versions.gradle b/versions.gradle
index d934da377..7d644e96b 100644
--- a/versions.gradle
+++ b/versions.gradle
@@ -15,6 +15,7 @@ dependencyManagement {
     dependency 'org.miracl.milagro.amcl:milagro-crypto-java:0.4.0'
     dependency 'com.google.guava:guava:27.0.1-jre'
     dependency 'com.google.code.findbugs:jsr305:1.3.9'
+    dependency 'commons-net:commons-net:3.6'
 
     dependency 'io.vertx:vertx-core:3.5.4'
     dependency 'junit:junit:4.12'
diff --git a/wire/build.gradle b/wire/build.gradle
index b319c2a5a..4b074219f 100644
--- a/wire/build.gradle
+++ b/wire/build.gradle
@@ -2,7 +2,7 @@ dependencies {
   implementation project(':types')
   implementation project(':core')
   implementation project(':consensus')
-  implementation project(':util')
+  implementation project(':util:core')
   implementation project(':ssz')
   implementation project(':chain')
   implementation project(':db:core')