diff --git a/examples/src/main/scala/examples/commons/SimpleBoxTransactionMemPool.scala b/examples/src/main/scala/examples/commons/SimpleBoxTransactionMemPool.scala
index e7de96479..1d9e54062 100644
--- a/examples/src/main/scala/examples/commons/SimpleBoxTransactionMemPool.scala
+++ b/examples/src/main/scala/examples/commons/SimpleBoxTransactionMemPool.scala
@@ -1,6 +1,7 @@
 package examples.commons
 
-import scorex.core.transaction.MemoryPool
+import akka.actor.{ActorRef, ActorSystem}
+import scorex.core.transaction.{ReferenceMempool, ReferenceMempoolActor}
 import scorex.util.ModifierId
 
 import scala.collection.concurrent.TrieMap
@@ -8,15 +9,14 @@ import scala.util.{Success, Try}
 
 
 case class SimpleBoxTransactionMemPool(unconfirmed: TrieMap[ModifierId, SimpleBoxTransaction])
-  extends MemoryPool[SimpleBoxTransaction, SimpleBoxTransactionMemPool] {
-  override type NVCT = SimpleBoxTransactionMemPool
+  extends ReferenceMempool[SimpleBoxTransaction, SimpleBoxTransactionMemPool] {
 
   //getters
   override def modifierById(id: ModifierId): Option[SimpleBoxTransaction] = unconfirmed.get(id)
 
   override def contains(id: ModifierId): Boolean = unconfirmed.contains(id)
 
-  override def getAll(ids: Seq[ModifierId]): Seq[SimpleBoxTransaction] = ids.flatMap(getById)
+  override def getAll(ids: Seq[ModifierId]): Seq[SimpleBoxTransaction] = ids.flatMap(modifierById)
 
   //modifiers
   override def put(tx: SimpleBoxTransaction): Try[SimpleBoxTransactionMemPool] = Success {
@@ -24,11 +24,8 @@ case class SimpleBoxTransactionMemPool(unconfirmed: TrieMap[ModifierId, SimpleBo
     this
   }
 
-  //todo
-  override def put(txs: Iterable[SimpleBoxTransaction]): Try[SimpleBoxTransactionMemPool] = Success(putWithoutCheck(txs))
-
-  override def putWithoutCheck(txs: Iterable[SimpleBoxTransaction]): SimpleBoxTransactionMemPool = {
-    txs.foreach(tx => unconfirmed.put(tx.id, tx))
+  override def putWithoutCheck(tx: SimpleBoxTransaction): SimpleBoxTransactionMemPool = {
+    unconfirmed.put(tx.id, tx)
     this
   }
 
@@ -38,9 +35,9 @@ case class SimpleBoxTransactionMemPool(unconfirmed: TrieMap[ModifierId, SimpleBo
   }
 
   override def take(limit: Int): Iterable[SimpleBoxTransaction] =
-    unconfirmed.values.toSeq.sortBy(-_.fee).take(limit)
+    unconfirmed.values.toSeq.sortBy(_.fee)(Ordering[Long].reverse).take(limit)
 
-  override def filter(condition: SimpleBoxTransaction => Boolean): SimpleBoxTransactionMemPool = {
+  override def filterBy(condition: SimpleBoxTransaction => Boolean): SimpleBoxTransactionMemPool = {
     unconfirmed.retain { (_, v) =>
       condition(v)
     }
@@ -50,7 +47,10 @@ case class SimpleBoxTransactionMemPool(unconfirmed: TrieMap[ModifierId, SimpleBo
   override def size: Int = unconfirmed.size
 }
 
-
 object SimpleBoxTransactionMemPool {
-  lazy val emptyPool: SimpleBoxTransactionMemPool = SimpleBoxTransactionMemPool(TrieMap())
+  def emptyPool: SimpleBoxTransactionMemPool = SimpleBoxTransactionMemPool(TrieMap())
+
+  def createMempoolActor(implicit system: ActorSystem): ActorRef = {
+    ReferenceMempoolActor[SimpleBoxTransaction, SimpleBoxTransactionMemPool](emptyPool)
+  }
 }
diff --git a/examples/src/main/scala/examples/hybrid/HybridNodeViewHolder.scala b/examples/src/main/scala/examples/hybrid/HybridNodeViewHolder.scala
index 2673215ff..527724335 100644
--- a/examples/src/main/scala/examples/hybrid/HybridNodeViewHolder.scala
+++ b/examples/src/main/scala/examples/hybrid/HybridNodeViewHolder.scala
@@ -1,22 +1,21 @@
 package examples.hybrid
 
 import akka.actor.{ActorRef, ActorSystem, Props}
-import examples.commons._
+import examples.commons.{Value, _}
 import examples.hybrid.blocks._
 import examples.hybrid.history.{HybridHistory, HybridSyncInfo}
 import examples.hybrid.mining.{HybridMiningSettings, HybridSettings}
 import examples.hybrid.state.HBoxStoredState
 import examples.hybrid.wallet.HBoxWallet
-import scorex.core.serialization.Serializer
+import scorex.core.NodeViewHolder
 import scorex.core.settings.ScorexSettings
-import scorex.core.transaction.Transaction
+import scorex.core.transaction.ReferenceMempoolActor
 import scorex.core.transaction.box.proposition.PublicKey25519Proposition
-import scorex.core.transaction.state.PrivateKey25519Companion
+import scorex.core.transaction.state.{PrivateKey25519, PrivateKey25519Companion}
 import scorex.core.utils.{NetworkTimeProvider, ScorexEncoding}
-import scorex.core.{ModifierTypeId, NodeViewHolder, NodeViewModifier}
-import scorex.util.encode.Base58
 import scorex.crypto.signatures.PublicKey
 import scorex.util.ScorexLogging
+import scorex.util.encode.Base58
 
 
 class HybridNodeViewHolder(hybridSettings: HybridSettings,
@@ -24,14 +23,18 @@ class HybridNodeViewHolder(hybridSettings: HybridSettings,
   extends NodeViewHolder[SimpleBoxTransaction, HybridBlock] {
 
   override type SI = HybridSyncInfo
-  override type HIS = HybridHistory
-  override type MS = HBoxStoredState
-  override type VL = HBoxWallet
-  override type MP = SimpleBoxTransactionMemPool
+  override type History = HybridHistory
+  override type State = HBoxStoredState
+  override type Vault = HBoxWallet
+  override type MPool = SimpleBoxTransactionMemPool
 
   override lazy val scorexSettings: ScorexSettings = hybridSettings.scorexSettings
   private lazy val minerSettings: HybridMiningSettings = hybridSettings.mining
 
+  override protected def createMemoryPoolActor(): ActorRef = {
+    ReferenceMempoolActor[SimpleBoxTransaction, MPool](restoreMempool().getOrElse(genesisMempool()))(context.system)
+  }
+
   override def preRestart(reason: Throwable, message: Option[Any]): Unit = {
     super.preRestart(reason, message)
     log.error("HybridNodeViewHolder has been restarted, not a valid situation!")
@@ -39,123 +42,191 @@ class HybridNodeViewHolder(hybridSettings: HybridSettings,
     System.exit(100) // this actor shouldn't be restarted at all so kill the whole app if that happened
   }
 
+  lazy val _genesisPow = HybridNodeViewHolder.generateGenesisPow(hybridSettings)
+  lazy val _genesisPos = HybridNodeViewHolder.generateGenesisPos(_genesisPow)
+  lazy val _genesisState = HybridNodeViewHolder.generateGenesisState(hybridSettings, _genesisPow, _genesisPos)
+
+  /** Hard-coded initial history all the honest nodes in a network are making progress from.
+    */
+  override protected def genesisHistory(): History = {
+    HybridNodeViewHolder.generateGenesisHistory(hybridSettings, timeProvider, _genesisPow, _genesisPos)
+  }
+
+  /** Hard-coded initial state all the honest nodes in a network are making progress from.
+    */
+  override protected def genesisState(): State = {
+    _genesisState
+  }
+
+  /** Hard-coded initial wallet all the honest nodes in a network are making progress from.
+    */
+  override protected def genesisVault(): Vault = {
+    HybridNodeViewHolder.generateGenesisWallet(hybridSettings, _genesisState, _genesisPow, _genesisPos)
+  }
+
+  /** Hard-coded initial Mempool all the honest nodes in a network are making progress from.
+    */
+  override protected def genesisMempool(): MPool = {
+    HybridNodeViewHolder.generateGenesisMemPool()
+  }
+
+  /**
+    * Restore a local history during a node startup. If no any stored view found
+    * (e.g. if it is a first launch of a node) None is to be returned
+    */
+  override def restoreHistory(): Option[History] = {
+    if (HBoxWallet.exists(hybridSettings.walletSettings)) {
+      Some(HybridHistory.readOrGenerate(scorexSettings, minerSettings, timeProvider))
+    } else {
+      None
+    }
+  }
+
   /**
-    * Hard-coded initial view all the honest nodes in a network are making progress from.
+    * Restore a local view during a node startup. If no any stored view found
+    * (e.g. if it is a first launch of a node) None is to be returned
+    */
+  override def restoreState(): Option[State] = {
+    if (HBoxWallet.exists(hybridSettings.walletSettings)) {
+      Some(HBoxStoredState.readOrGenerate(scorexSettings))
+    } else {
+      None
+    }
+  }
+
+  /**
+    * Restore a local view during a node startup. If no any stored view found
+    * (e.g. if it is a first launch of a node) None is to be returned
     */
-  override protected def genesisState: (HIS, MS, VL, MP) =
-    HybridNodeViewHolder.generateGenesisState(hybridSettings, timeProvider)
+  override def restoreVault(): Option[Vault] = {
+    if (HBoxWallet.exists(hybridSettings.walletSettings)) {
+      Some(HBoxWallet.readOrGenerate(hybridSettings.walletSettings, 1))
+    } else {
+      None
+    }
+  }
 
   /**
     * Restore a local view during a node startup. If no any stored view found
     * (e.g. if it is a first launch of a node) None is to be returned
     */
-  override def restoreState(): Option[(HIS, MS, VL, MP)] = {
+  override def restoreMempool(): Option[MPool] = {
     if (HBoxWallet.exists(hybridSettings.walletSettings)) {
-      Some((
-        HybridHistory.readOrGenerate(scorexSettings, minerSettings, timeProvider),
-        HBoxStoredState.readOrGenerate(scorexSettings),
-        HBoxWallet.readOrGenerate(hybridSettings.walletSettings, 1),
-        SimpleBoxTransactionMemPool.emptyPool))
-    } else None
+      Some(SimpleBoxTransactionMemPool.emptyPool)
+    } else {
+      None
+    }
   }
 }
 
 object HybridNodeViewHolder extends ScorexLogging with ScorexEncoding {
-  def generateGenesisState(hybridSettings: HybridSettings,
-                           timeProvider: NetworkTimeProvider):
-  (HybridHistory, HBoxStoredState, HBoxWallet, SimpleBoxTransactionMemPool) = {
-    val settings: ScorexSettings = hybridSettings.scorexSettings
-    val minerSettings: HybridMiningSettings = hybridSettings.mining
-
-    val GenesisAccountsNum = 50
-    val GenesisBalance = Value @@ 100000000L
-
-    //propositions with wallet seeds minerNode1 (20accs), minerNode2 (20 accs), minerNode3 (10 accs)
-    val icoMembers: IndexedSeq[PublicKey25519Proposition] = IndexedSeq(
-      "Gh5ipRV2fzCn5176CPHnW4EVk9MR2HU6m91ZhoPxUwHN",
-      "5r37KJVi3DSKsh5atfhdN6CbpvEh6mKwEZvzuCWjtcf1",
-      "71bFWP8JFmCiGS9m9b6GZfwmtgFUb1WDHmfk5mb63YEf",
-      "7r3XqE1ZvTHzmd6teP3kUBm1KvAi2Kwkfj69VSo7VpPW",
-      "Bf4GE6HBLbsHzGex93uYb1nN52HeBKfVC84ZxDraH3ZB",
-      "B9sUJG3fUwRf33VaTEae2KxVqLHt7Ft1W69mFd9G5ZTb",
-      "8ZSn9YP1rAgy5zRKzXbds8QHPggKEY9zWW7ZWjTvVQYf",
-      "DHjxreyiz7ZLW4CH6XDVma4dWidwqRM3coacs6d6vXD4",
-      "AmvdYNLLA4ZVj7Wj1FKKi1E9Eve7qnb6peXB8dQThQEz",
-      "FBa8ZrF5CBVTZfj1enFvjXUTySJE6cCnrhx27Rct2aFH",
-      "5CQtS7mWcNUrbW9TFVafmgP9C2bvUHcFAx6T9f791fVB",
-      "BYiAvhAs2ZC7YCuzjez52tfHRVBep6ZmZToUMZCtrV45",
-      "Bqd2xjzfaztCv2hLoaedxJ73yWQpbVqRgQobs2BGx3q4",
-      "HvqRZ2TANTqFZJ7Qrpg2r6u14f1J7ZULeoM9cCRFq4QZ",
-      "2oGZpxT1SceyZSVfs4R2hNYZopNL3LpVbPQ9seQbQpLo",
-      "4u3xxr6tNBcY9NSC918xkikYrYC9RxyuTzksaQsbsXkK",
-      "6uetbFeCJ4nhe9r1bbMN3D7sdBPJtafqacrLTJ21nfcK",
-      "saLQifmdmE7urULqeJht8uWou7xh8qkapmmu3HM3SaT",
-      "DqkHG29Rm5YSCahuR1VxytPFJFBqUhQKhAq7kokLakDc",
-      "D9KQHUj4zkMJBYqfjoWbkMU2SPiuH6UA16Tq8Ns1zHwT",
-      "GQz8mafKfC8Scb11ppCagiPGAHVSzDd3DQhZgsrzHKq8",
-      "GBa7NdFDQYjkEsjn4xJvgYBZdwrN6Ds6FHMzcMhgAqFw",
-      "Eozk3S7aTZStqAEmN8pLYAcSNpgNtUBBHykeNPqcKbwE",
-      "26AZ94vmuVMiruQbxpaArtooeByf4mg7YERm7ASPLtzX",
-      "4FLYR7RY2VPwxrk11naQeE2kuHe2sm6gttxFYzMAsipU",
-      "B3HzLmPcDribF2csqSvdteTVcQsNkmxCKNFR3xLZ3Rqu",
-      "2YE8p31Fr7KfgQTSWdCWK7C1wk4Y3Yb3gzvecHfjGQCS",
-      "6haBGvcBz8ZrBza5BBWAGtVghKoSDunp1JXyFjhRL9Pg",
-      "8Na86fSM2Cv5LvoezW5aL8h2qaP76Cs7EXVRjPZvY2dG",
-      "5TSGDgKxXQmBL7K1UjXJJijA9uEZWYku7hQZjA4YchmJ",
-      "6KDfFLDnSxTBQ58NvBWqeXLTTJtbALrw2uNDW2haGkTs",
-      "G8vHzNUhbs8LH12p27dexZnXhYXcHa2F5rybLDyRC59y",
-      "BjwrFU2FyBBB7x2vn3d5r3P9THG7kJi37A1VcJZj9ngy",
-      "BXs7geU54HqMCicgzsuWNeF2CgD7DfQWg2KyJSuu35cj",
-      "8r11HX4Ap8V9JsUVD7fivyzLzZ14DG9fSHhXDb2pgoeo",
-      "FKroztkLwNbqibtwP6g5GYECuVRoVShT2GyuaATYYWeZ",
-      "FUsLAekPGpPPQvvksV1VphYzPJgaEsbwEiBxEh4U9T6p",
-      "7FkG9kkU66XQtPJuzgyAEB4Lcw4b78PZHfXwNbFgvohA",
-      "ASpaQgkEP49UHUR8hAMrruiG4HpGo6WybvJ88njD5L7B",
-      "FRRXWdY6br8kcTWk4VWnwiL7kAsgNvAbRyoXxdAkFqZt",
-      "5YgmHSQ9AZpniZ9DMfTkZSfM3A1BJsXKqCAtCSr3Ybkq",
-      "7vV4aqkg1YY5VnM34oJ7BRMXZyvULGPva6Tesmng9XvH",
-      "45VGbsfFeiXkW2uoC7tDRVUSHjnYhtpfrYN57wTANHsn",
-      "8QwTmye6VsHx3fkAvmJqvSgHPjdPCaT3wakEfpujsWM5",
-      "6nUtKXw7WFgV2tRuFyYwBrg4kBMYzADekPqLTwnUccxV",
-      "3Kw5jix8XMWj2SHsxt7c1w9iiK3s6qc4NMyY6bDUXvTg",
-      "EVjrmbKvTkVk7JRzDEaHBL2tpcdAtHgyNhDyPXGcAXLv",
-      "GXkCiK2P7khngAtfhG8TSqm4nfPbpMDNFBiG8CF41ZtP",
-      "8etCeR343fg5gktxMh5j64zofFvWuyNTwmHAzWbsptoC",
-      "AnwYrjV3yb9NuYWz31C758TZGTUCLD7zZdSYubbewygt"
-    ).map(s => PublicKey25519Proposition(PublicKey @@ Base58.decode(s).get))
-      .ensuring(_.length == GenesisAccountsNum)
-
-    val genesisAccount = PrivateKey25519Companion.generateKeys("genesis".getBytes)
-    val genesisAccountPriv = genesisAccount._1
-    val powGenesis = PowBlock(minerSettings.GenesisParentId, minerSettings.GenesisParentId, 1481110008516L, 38,
-      0, Array.fill(32)(0: Byte), genesisAccount._2, Seq())
 
+  val (genesisAccountPrivate: PrivateKey25519, genesisAccountPublic: PublicKey25519Proposition) = {
+    PrivateKey25519Companion.generateKeys("genesis".getBytes)
+  }
 
+  val GenesisAccountsNum: Int = 50
+  val GenesisBalance: Value = Value @@ 100000000L
+
+  //propositions with wallet seeds minerNode1 (20accs), minerNode2 (20 accs), minerNode3 (10 accs)
+  val icoMembers: IndexedSeq[PublicKey25519Proposition] = IndexedSeq(
+    "Gh5ipRV2fzCn5176CPHnW4EVk9MR2HU6m91ZhoPxUwHN",
+    "5r37KJVi3DSKsh5atfhdN6CbpvEh6mKwEZvzuCWjtcf1",
+    "71bFWP8JFmCiGS9m9b6GZfwmtgFUb1WDHmfk5mb63YEf",
+    "7r3XqE1ZvTHzmd6teP3kUBm1KvAi2Kwkfj69VSo7VpPW",
+    "Bf4GE6HBLbsHzGex93uYb1nN52HeBKfVC84ZxDraH3ZB",
+    "B9sUJG3fUwRf33VaTEae2KxVqLHt7Ft1W69mFd9G5ZTb",
+    "8ZSn9YP1rAgy5zRKzXbds8QHPggKEY9zWW7ZWjTvVQYf",
+    "DHjxreyiz7ZLW4CH6XDVma4dWidwqRM3coacs6d6vXD4",
+    "AmvdYNLLA4ZVj7Wj1FKKi1E9Eve7qnb6peXB8dQThQEz",
+    "FBa8ZrF5CBVTZfj1enFvjXUTySJE6cCnrhx27Rct2aFH",
+    "5CQtS7mWcNUrbW9TFVafmgP9C2bvUHcFAx6T9f791fVB",
+    "BYiAvhAs2ZC7YCuzjez52tfHRVBep6ZmZToUMZCtrV45",
+    "Bqd2xjzfaztCv2hLoaedxJ73yWQpbVqRgQobs2BGx3q4",
+    "HvqRZ2TANTqFZJ7Qrpg2r6u14f1J7ZULeoM9cCRFq4QZ",
+    "2oGZpxT1SceyZSVfs4R2hNYZopNL3LpVbPQ9seQbQpLo",
+    "4u3xxr6tNBcY9NSC918xkikYrYC9RxyuTzksaQsbsXkK",
+    "6uetbFeCJ4nhe9r1bbMN3D7sdBPJtafqacrLTJ21nfcK",
+    "saLQifmdmE7urULqeJht8uWou7xh8qkapmmu3HM3SaT",
+    "DqkHG29Rm5YSCahuR1VxytPFJFBqUhQKhAq7kokLakDc",
+    "D9KQHUj4zkMJBYqfjoWbkMU2SPiuH6UA16Tq8Ns1zHwT",
+    "GQz8mafKfC8Scb11ppCagiPGAHVSzDd3DQhZgsrzHKq8",
+    "GBa7NdFDQYjkEsjn4xJvgYBZdwrN6Ds6FHMzcMhgAqFw",
+    "Eozk3S7aTZStqAEmN8pLYAcSNpgNtUBBHykeNPqcKbwE",
+    "26AZ94vmuVMiruQbxpaArtooeByf4mg7YERm7ASPLtzX",
+    "4FLYR7RY2VPwxrk11naQeE2kuHe2sm6gttxFYzMAsipU",
+    "B3HzLmPcDribF2csqSvdteTVcQsNkmxCKNFR3xLZ3Rqu",
+    "2YE8p31Fr7KfgQTSWdCWK7C1wk4Y3Yb3gzvecHfjGQCS",
+    "6haBGvcBz8ZrBza5BBWAGtVghKoSDunp1JXyFjhRL9Pg",
+    "8Na86fSM2Cv5LvoezW5aL8h2qaP76Cs7EXVRjPZvY2dG",
+    "5TSGDgKxXQmBL7K1UjXJJijA9uEZWYku7hQZjA4YchmJ",
+    "6KDfFLDnSxTBQ58NvBWqeXLTTJtbALrw2uNDW2haGkTs",
+    "G8vHzNUhbs8LH12p27dexZnXhYXcHa2F5rybLDyRC59y",
+    "BjwrFU2FyBBB7x2vn3d5r3P9THG7kJi37A1VcJZj9ngy",
+    "BXs7geU54HqMCicgzsuWNeF2CgD7DfQWg2KyJSuu35cj",
+    "8r11HX4Ap8V9JsUVD7fivyzLzZ14DG9fSHhXDb2pgoeo",
+    "FKroztkLwNbqibtwP6g5GYECuVRoVShT2GyuaATYYWeZ",
+    "FUsLAekPGpPPQvvksV1VphYzPJgaEsbwEiBxEh4U9T6p",
+    "7FkG9kkU66XQtPJuzgyAEB4Lcw4b78PZHfXwNbFgvohA",
+    "ASpaQgkEP49UHUR8hAMrruiG4HpGo6WybvJ88njD5L7B",
+    "FRRXWdY6br8kcTWk4VWnwiL7kAsgNvAbRyoXxdAkFqZt",
+    "5YgmHSQ9AZpniZ9DMfTkZSfM3A1BJsXKqCAtCSr3Ybkq",
+    "7vV4aqkg1YY5VnM34oJ7BRMXZyvULGPva6Tesmng9XvH",
+    "45VGbsfFeiXkW2uoC7tDRVUSHjnYhtpfrYN57wTANHsn",
+    "8QwTmye6VsHx3fkAvmJqvSgHPjdPCaT3wakEfpujsWM5",
+    "6nUtKXw7WFgV2tRuFyYwBrg4kBMYzADekPqLTwnUccxV",
+    "3Kw5jix8XMWj2SHsxt7c1w9iiK3s6qc4NMyY6bDUXvTg",
+    "EVjrmbKvTkVk7JRzDEaHBL2tpcdAtHgyNhDyPXGcAXLv",
+    "GXkCiK2P7khngAtfhG8TSqm4nfPbpMDNFBiG8CF41ZtP",
+    "8etCeR343fg5gktxMh5j64zofFvWuyNTwmHAzWbsptoC",
+    "AnwYrjV3yb9NuYWz31C758TZGTUCLD7zZdSYubbewygt"
+  ).map(s => PublicKey25519Proposition(PublicKey @@ Base58.decode(s).get))
+    .ensuring(_.length == GenesisAccountsNum)
+
+  def generateGenesisPow(settings: HybridSettings): PowBlock = {
+    val minerSettings = settings.mining
+    PowBlock(minerSettings.GenesisParentId, minerSettings.GenesisParentId, 1481110008516L, 38,
+      0, Array.fill(32)(0: Byte), genesisAccountPublic, Seq())
+  }
+
+  def generateGenesisPos(powGenesis: PowBlock): PosBlock = {
     val genesisTxs = Seq(SimpleBoxTransaction(
-      IndexedSeq(genesisAccountPriv -> Nonce @@ 0L),
+      IndexedSeq(genesisAccountPrivate -> Nonce @@ 0L),
       icoMembers.map(_ -> GenesisBalance),
       0L,
       0L))
-
-
-    log.debug(s"Initialize state with transaction ${genesisTxs.headOption} with boxes ${genesisTxs.headOption.map(_.newBoxes)}")
-
-    val genesisBox = PublicKey25519NoncedBox(genesisAccountPriv.publicImage, Nonce @@ 0L, GenesisBalance)
+    log.debug(s"Initialize state with transaction ${genesisTxs.headOption} " +
+              s"with boxes ${genesisTxs.headOption.map(_.newBoxes)}")
+    val genesisBox = PublicKey25519NoncedBox(genesisAccountPrivate.publicImage, Nonce @@ 0L, GenesisBalance)
     val attachment = "genesis attachment".getBytes
-    val posGenesis = PosBlock.create(powGenesis.id, 0, genesisTxs, genesisBox, attachment, genesisAccountPriv)
+    PosBlock.create(powGenesis.id, 0, genesisTxs, genesisBox, attachment, genesisAccountPrivate)
+  }
 
-    var history = HybridHistory.readOrGenerate(settings, minerSettings, timeProvider)
-    history = history.append(powGenesis).get._1
-    history = history.append(posGenesis).get._1
+  def generateGenesisHistory(settings: HybridSettings,
+                             timeProvider: NetworkTimeProvider,
+                             powGenesis: PowBlock,
+                             posGenesis: PosBlock): HybridHistory = {
+    HybridHistory
+      .readOrGenerate(settings.scorexSettings,  settings.mining, timeProvider)
+      .append(powGenesis).get._1
+      .append(posGenesis).get._1
+  }
 
-    val gs = HBoxStoredState.genesisState(settings, Seq[HybridBlock](posGenesis, powGenesis))
-    val gw = HBoxWallet.genesisWallet(hybridSettings.walletSettings, Seq[HybridBlock](posGenesis, powGenesis))
-      .ensuring(_.boxes().map(_.box.value.toLong).sum >= GenesisBalance ||
-        !encoder.encode(hybridSettings.walletSettings.seed).startsWith("genesis"))
-      .ensuring(_.boxes().forall(b => gs.closedBox(b.box.id).isDefined))
+  def generateGenesisState(settings: HybridSettings, powGenesis: PowBlock, posGenesis: PosBlock): HBoxStoredState = {
+    HBoxStoredState.genesisState(settings.scorexSettings, Seq[HybridBlock](posGenesis, powGenesis))
+  }
 
-    (history, gs, gw, SimpleBoxTransactionMemPool.emptyPool)
+  def generateGenesisWallet(settings: HybridSettings,
+                            state: HBoxStoredState,
+                            powGenesis: PowBlock,
+                            posGenesis: PosBlock):HBoxWallet = {
+    HBoxWallet.genesisWallet(settings.walletSettings, Seq[HybridBlock](posGenesis, powGenesis))
+      .ensuring(_.boxes().map(_.box.value.toLong).sum >= GenesisBalance ||
+        !encoder.encode(settings.walletSettings.seed).startsWith("genesis"))
+          .ensuring(_.boxes().forall(b => state.closedBox(b.box.id).isDefined))
   }
+
+  def generateGenesisMemPool() : SimpleBoxTransactionMemPool = SimpleBoxTransactionMemPool.emptyPool
 }
 
 object HybridNodeViewHolderRef {
diff --git a/examples/src/main/scala/examples/hybrid/simulations/PrivateChain.scala b/examples/src/main/scala/examples/hybrid/simulations/PrivateChain.scala
index 721a2a990..c7a768269 100644
--- a/examples/src/main/scala/examples/hybrid/simulations/PrivateChain.scala
+++ b/examples/src/main/scala/examples/hybrid/simulations/PrivateChain.scala
@@ -26,10 +26,8 @@ import scala.util.Try
   */
 object PrivateChain extends App with ScorexLogging with ScorexEncoding {
 
-  val proposition: PublicKey25519Proposition = PublicKey25519Proposition(PublicKey @@ scorex.utils.Random.randomBytes(32))
-
-  def genesisState(): (HybridHistory, HBoxStoredState, HBoxWallet, SimpleBoxTransactionMemPool)  = {
-    HybridNodeViewHolder.generateGenesisState(hybridSettings, new NetworkTimeProvider(settings.ntp))
+  val proposition: PublicKey25519Proposition = {
+    PublicKey25519Proposition(PublicKey @@ scorex.utils.Random.randomBytes(32))
   }
 
   def generatePow(h: HybridHistory, brother: Boolean, hashesPerSecond: Int): PowBlock = {
@@ -64,8 +62,12 @@ object PrivateChain extends App with ScorexLogging with ScorexEncoding {
 
     Path.apply(settings.dataDir).deleteRecursively()
 
-    var (history, _, wallet, _) = genesisState()
-
+    val timeProvider = new NetworkTimeProvider(settings.ntp)
+    val genesisPow = HybridNodeViewHolder.generateGenesisPow(hybridSettings)
+    val genesisPos = HybridNodeViewHolder.generateGenesisPos(genesisPow)
+    var history = HybridNodeViewHolder.generateGenesisHistory(hybridSettings, timeProvider, genesisPow, genesisPos)
+    val genesisState = HybridNodeViewHolder.generateGenesisState(hybridSettings, genesisPow, genesisPos)
+    val wallet =  HybridNodeViewHolder.generateGenesisWallet(hybridSettings, genesisState, genesisPow, genesisPos)
     val boxes = wallet.boxes().map(_.box).take(adversarialStakePercent)
     val boxKeys = boxes.flatMap(b => wallet.secretByPublicImage(b.proposition).map(s => (b, s)))
 
diff --git a/examples/src/test/scala/hybrid/HybridGenerators.scala b/examples/src/test/scala/hybrid/HybridGenerators.scala
index 51ff57d9c..7c76a63eb 100644
--- a/examples/src/test/scala/hybrid/HybridGenerators.scala
+++ b/examples/src/test/scala/hybrid/HybridGenerators.scala
@@ -9,6 +9,7 @@ import examples.hybrid.state.HBoxStoredState
 import org.scalacheck.rng.Seed
 import org.scalacheck.{Arbitrary, Gen}
 import scorex.core.block.Block._
+import scorex.core.transaction.MempoolReader
 import scorex.core.transaction.box.proposition.PublicKey25519Proposition
 import scorex.core.transaction.proof.Signature25519
 import scorex.core.transaction.state._
@@ -169,9 +170,8 @@ trait HybridGenerators extends ExamplesCommonGenerators
     } yield PosBlock.create(id, timestamp, txs, box.copy(proposition = generator.publicImage), attach, generator)
   }.apply(Gen.Parameters.default, Seed.random()).get
 
-
-  def modifierWithTransactions(memoryPoolOpt: Option[SimpleBoxTransactionMemPool],
-                               customTransactionsOpt: Option[Seq[SimpleBoxTransaction]]): PosBlock = {
+  def modifierWithTransactions(memoryPoolOpt: Option[MempoolReader[TX]],
+                               customTransactionsOpt: Option[Seq[TX]]): PosBlock = {
 
     val (id, timestamp, box, attach, generator) = (for {
       id <- modifierIdGen
diff --git a/examples/src/test/scala/hybrid/HybridSanity.scala b/examples/src/test/scala/hybrid/HybridSanity.scala
index 22274ac1c..0cb0f9c83 100644
--- a/examples/src/test/scala/hybrid/HybridSanity.scala
+++ b/examples/src/test/scala/hybrid/HybridSanity.scala
@@ -1,5 +1,6 @@
 package hybrid
 
+import akka.actor.{ActorRef, ActorSystem}
 import examples.commons.{PublicKey25519NoncedBox, SimpleBoxTransaction, SimpleBoxTransactionMemPool}
 import examples.hybrid.blocks.{HybridBlock, PosBlock}
 import examples.hybrid.history.{HybridHistory, HybridSyncInfo}
@@ -19,14 +20,15 @@ class HybridSanity extends BlockchainSanity[PublicKey25519Proposition,
   SimpleBoxTransactionMemPool,
   HBoxStoredState,
   HybridHistory] with BlockchainPerformance[SimpleBoxTransaction, HybridBlock, HybridSyncInfo,
-                                            SimpleBoxTransactionMemPool, HBoxStoredState, HybridHistory]
+                                            HBoxStoredState, HybridHistory]
   with HybridGenerators {
 
   private val walletSettings = originalSettings.walletSettings.copy(seed = "p")
 
-  //Node view components
-  override lazy val memPool: SimpleBoxTransactionMemPool = SimpleBoxTransactionMemPool.emptyPool
-  override lazy val memPoolGenerator: Gen[SimpleBoxTransactionMemPool] = emptyMemPoolGen
+  override protected def createMempoolActor(system: ActorSystem): ActorRef = {
+    SimpleBoxTransactionMemPool.createMempoolActor(system)
+  }
+
   override lazy val transactionGenerator: Gen[TX] = simpleBoxTransactionGen
   override lazy val wallet = (0 until 100).foldLeft(HBoxWallet.readOrGenerate(walletSettings))((w, _) => w.generateNewSecret())
-}
\ No newline at end of file
+}
diff --git a/examples/src/test/scala/hybrid/NodeViewHolderGenerators.scala b/examples/src/test/scala/hybrid/NodeViewHolderGenerators.scala
index d51a2d173..ef7d61305 100644
--- a/examples/src/test/scala/hybrid/NodeViewHolderGenerators.scala
+++ b/examples/src/test/scala/hybrid/NodeViewHolderGenerators.scala
@@ -17,15 +17,25 @@ trait NodeViewHolderGenerators {
 
   class NodeViewHolderForTests(h: HT, s: ST) extends HybridNodeViewHolder(settings, new NetworkTimeProvider(settings.scorexSettings.ntp)) {
 
-    override protected def genesisState: (HIS, MS, VL, MP) = {
-      @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-      val store = lsmStoreGen.sample.get
+    override protected def genesisHistory(): History = h
+
+    override protected def genesisState(): State = s
+
+    override protected def genesisVault(): Vault = {
+      val store = lsmStoreGen.sample.getOrElse(throw new Exception("lsmStoreGen.sample is None"))
       val seed = Array.fill(10)(1: Byte)
-      val gw = new HBoxWallet(seed, store)
-      (h, s, gw, SimpleBoxTransactionMemPool.emptyPool)
+      new HBoxWallet(seed, store)
     }
 
-    override def restoreState(): Option[(HIS, MS, VL, MP)] = None
+    override def genesisMempool(): MPool = SimpleBoxTransactionMemPool.emptyPool
+
+    override def restoreHistory(): Option[History] = None
+
+    override def restoreState(): Option[State] = None
+
+    override def restoreVault(): Option[Vault] = None
+
+    override def restoreMempool(): Option[MPool] = None
   }
 
   object NodeViewHolderForTests {
@@ -45,4 +55,4 @@ trait NodeViewHolderGenerators {
     val eventListener = TestProbe()
     (ref, eventListener, m, s, h)
   }
-}
\ No newline at end of file
+}
diff --git a/examples/src/test/scala/hybrid/NodeViewSynchronizerGenerators.scala b/examples/src/test/scala/hybrid/NodeViewSynchronizerGenerators.scala
index 077a19336..914acd2c6 100644
--- a/examples/src/test/scala/hybrid/NodeViewSynchronizerGenerators.scala
+++ b/examples/src/test/scala/hybrid/NodeViewSynchronizerGenerators.scala
@@ -3,22 +3,29 @@ package hybrid
 import akka.actor.{ActorRef, ActorSystem, Props}
 import akka.testkit.TestProbe
 import commons.ExamplesCommonGenerators
-import examples.commons.SimpleBoxTransactionMemPool
+import examples.commons.{SimpleBoxTransaction, SimpleBoxTransactionMemPool}
 import examples.hybrid.HybridApp
-import examples.hybrid.history.HybridSyncInfoMessageSpec
+import examples.hybrid.blocks.HybridBlock
+import examples.hybrid.history.{HybridSyncInfo, HybridSyncInfoMessageSpec}
 import io.iohk.iodb.ByteArrayWrapper
 import scorex.core._
-import scorex.core.app.Version
 import scorex.core.network.NodeViewSynchronizer.ReceivableMessages.{ChangedHistory, ChangedMempool}
 import scorex.core.network._
+import scorex.core.transaction.ReferenceMempoolActor
 import scorex.core.utils.NetworkTimeProvider
 import scorex.testkit.generators.CoreGenerators
+import scorex.testkit.properties.SynchronizerFixture
+import scorex.testkit.utils.SysId
 
 import scala.concurrent.ExecutionContext.Implicits.global
 
-@SuppressWarnings(Array("org.wartremover.warts.TraversableOps"))
 trait NodeViewSynchronizerGenerators {
-  this: ModifierGenerators with StateGenerators with HistoryGenerators with HybridTypes with CoreGenerators with ExamplesCommonGenerators =>
+  this: ModifierGenerators
+    with StateGenerators
+    with HistoryGenerators
+    with HybridTypes
+    with CoreGenerators
+    with ExamplesCommonGenerators =>
 
   object NodeViewSynchronizerForTests {
     def props(networkControllerRef: ActorRef,
@@ -31,31 +38,35 @@ trait NodeViewSynchronizerGenerators {
         HybridApp.modifierSerializers)
   }
 
-  def nodeViewSynchronizer(implicit system: ActorSystem):
-  (ActorRef, HSI, PM, TX, ConnectedPeer, TestProbe, TestProbe, TestProbe, TestProbe) = {
-    @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-    val h = historyGen.sample.get
-    @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-    val sRaw = stateGen.sample.get
+  def createFixture(): SynchronizerFixture[SimpleBoxTransaction, HybridBlock, HybridSyncInfo] = {
+    implicit val system: ActorSystem = ActorSystem("WithIsoFix-%d".format(SysId.incrementAndGet()))
+    val h = historyGen.sample.getOrElse(throw new Exception("Empty historyGen.sample"))
+    val sRaw = stateGen.sample.getOrElse(throw new Exception("Empty stateGen.sample"))
     val mempool = SimpleBoxTransactionMemPool.emptyPool
-    val v = h.openSurfaceIds().last
+    val v = h.openSurfaceIds().lastOption.getOrElse(throw new Exception("Empty history.openSurfaceIds"))
     sRaw.store.update(ByteArrayWrapper(idToBytes(v)), Seq(), Seq())
     val s = sRaw.copy(version = idToVersion(v))
 
     val ncProbe = TestProbe("NetworkControllerProbe")
     val vhProbe = TestProbe("ViewHolderProbe")
     val pchProbe = TestProbe("PeerHandlerProbe")
-    val eventListener = TestProbe("EventListener")
-
-    val ref = system.actorOf(NodeViewSynchronizerForTests.props(ncProbe.ref, vhProbe.ref))
-    ref ! ChangedHistory(h)
-    ref ! ChangedMempool(mempool)
-    val m = totallyValidModifier(h, s)
-    @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-    val tx = simpleBoxTransactionGen.sample.get
-    @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-    val p: ConnectedPeer = connectedPeerGen(pchProbe.ref).sample.get
-
-    (ref, h.syncInfo, m, tx, p, pchProbe, ncProbe, vhProbe, eventListener)
+
+    val syncRef = system.actorOf(NodeViewSynchronizerForTests.props(ncProbe.ref, vhProbe.ref))
+    syncRef ! ChangedHistory(h)
+    syncRef ! ChangedMempool(mempool)
+
+    new SynchronizerFixture(
+      system,
+      node = syncRef,
+      memoryPool = ReferenceMempoolActor[TX, SimpleBoxTransactionMemPool](mempool),
+      syncInfo = h.syncInfo,
+      mod = totallyValidModifier(h, s),
+      tx = simpleBoxTransactionGen.sample.getOrElse(throw new Exception("Empty simpleBoxTransactionGen.sample")),
+      peer = connectedPeerGen(pchProbe.ref).sample.getOrElse(throw new Exception("Empty connectedPeerGen.sample")),
+      pchProbe,
+      ncProbe,
+      vhProbe,
+      eventListener = TestProbe("EventListener")
+    )
   }
-}
\ No newline at end of file
+}
diff --git a/examples/src/test/scala/hybrid/NodeViewSynchronizerSpec.scala b/examples/src/test/scala/hybrid/NodeViewSynchronizerSpec.scala
index bec99b669..636ef73af 100644
--- a/examples/src/test/scala/hybrid/NodeViewSynchronizerSpec.scala
+++ b/examples/src/test/scala/hybrid/NodeViewSynchronizerSpec.scala
@@ -1,6 +1,6 @@
 package hybrid
 
-import examples.commons.{SimpleBoxTransaction, SimpleBoxTransactionMemPool}
+import examples.commons.SimpleBoxTransaction
 import examples.hybrid.blocks.HybridBlock
 import examples.hybrid.history.{HybridHistory, HybridSyncInfo}
 import examples.hybrid.state.HBoxStoredState
@@ -8,7 +8,4 @@ import scorex.testkit.properties.NodeViewSynchronizerTests
 
 class NodeViewSynchronizerSpec
   extends NodeViewSynchronizerTests[SimpleBoxTransaction, HybridBlock, HBoxStoredState, HybridSyncInfo,
-                                    HybridHistory, SimpleBoxTransactionMemPool] with HybridGenerators {
-
-  override lazy val memPool: SimpleBoxTransactionMemPool = SimpleBoxTransactionMemPool.emptyPool
-}
+                                    HybridHistory] with HybridGenerators
diff --git a/src/main/scala/scorex/core/NodeViewComponent.scala b/src/main/scala/scorex/core/NodeViewComponent.scala
index a06e4ddc2..7db8615f2 100644
--- a/src/main/scala/scorex/core/NodeViewComponent.scala
+++ b/src/main/scala/scorex/core/NodeViewComponent.scala
@@ -5,3 +5,11 @@ trait NodeViewComponent {
 
   type NVCT >: self.type <: NodeViewComponent
 }
+
+object NodeViewComponent {
+  trait ComponentType
+  object StateComponent extends ComponentType
+  object HistoryComponent extends ComponentType
+  object MempoolComponent extends ComponentType
+  object VaultComponent extends ComponentType
+}
diff --git a/src/main/scala/scorex/core/NodeViewComponentOperation.scala b/src/main/scala/scorex/core/NodeViewComponentOperation.scala
new file mode 100644
index 000000000..1463a336c
--- /dev/null
+++ b/src/main/scala/scorex/core/NodeViewComponentOperation.scala
@@ -0,0 +1,18 @@
+package scorex.core
+
+import scorex.core.NodeViewComponent.ComponentType
+
+/** Base trait for all node view operations, which should be sent to a memory node view component
+  */
+trait NodeViewComponentOperation
+
+object NodeViewComponentOperation {
+
+  /** Get the reader for the memory pool, returns a component reader instance
+    */
+  case class GetReader(componentType: ComponentType) extends NodeViewComponentOperation
+
+  /** Mode for the memory pool operation
+    */
+  trait OperationMode[Op <: NodeViewComponentOperation]
+}
diff --git a/src/main/scala/scorex/core/NodeViewHolder.scala b/src/main/scala/scorex/core/NodeViewHolder.scala
index 848e8bb20..13b6ce7a4 100644
--- a/src/main/scala/scorex/core/NodeViewHolder.scala
+++ b/src/main/scala/scorex/core/NodeViewHolder.scala
@@ -1,28 +1,33 @@
 package scorex.core
 
-import akka.actor.Actor
-import scorex.core.consensus.History.ProgressInfo
-import scorex.core.consensus.{History, SyncInfo}
+import akka.actor.{Actor, ActorRef}
+import akka.pattern._
+import akka.util.Timeout
+import scorex.core.NodeViewComponent._
+import scorex.core.NodeViewComponentOperation.GetReader
+import scorex.core.consensus.{HistoryReader, SyncInfo}
 import scorex.core.network.NodeViewSynchronizer.ReceivableMessages.NodeViewHolderEvent
 import scorex.core.settings.ScorexSettings
 import scorex.core.transaction._
-import scorex.core.transaction.state.{MinimalState, TransactionValidation}
-import scorex.core.transaction.wallet.Vault
-import scorex.core.utils.ScorexEncoding
-import scorex.util.ScorexLogging
-import scala.annotation.tailrec
-import scala.util.{Failure, Success, Try}
+import scorex.core.transaction.state.{MinimalState, StateHistoryActor, StateReader}
+import scorex.core.transaction.wallet.VaultReader
+import scorex.util.{ScorexEncoding, ScorexLogging}
 
+import scala.concurrent.duration._
+import scala.concurrent.{ExecutionContext, Future}
+import scala.reflect.ClassTag
+import scala.util.{Failure, Success}
 
-/**
-  * Composite local view of the node
+
+/** Local view coordinator of the node.
   *
-  * Contains instances for History, MinimalState, Vault, MemoryPool.
-  * The instances are read-only for external world.
-  * Updates of the composite view(the instances are to be performed atomically.
+  * Coordinates History, MinimalState, Vault, MemoryPool.
+  * Updates of the composite view are to be performed atomically.
   *
-  * @tparam TX
-  * @tparam PMOD
+  * The main data structure a node software is taking care about, a node view consists
+  * of four elements to be updated atomically: history (log of persistent modifiers),
+  * state (result of log's modifiers application to pre-historical(genesis) state,
+  * user-specific information stored in vault (it could be e.g. a wallet), and a memory pool.
   */
 trait NodeViewHolder[TX <: Transaction, PMOD <: PersistentNodeViewModifier]
   extends Actor with ScorexLogging with ScorexEncoding {
@@ -30,343 +35,246 @@ trait NodeViewHolder[TX <: Transaction, PMOD <: PersistentNodeViewModifier]
   import NodeViewHolder.ReceivableMessages._
   import NodeViewHolder._
   import scorex.core.network.NodeViewSynchronizer.ReceivableMessages._
+  import scorex.core.transaction.MempoolOperation._
+  import scorex.core.transaction.state.StateOperation._
 
   type SI <: SyncInfo
-  type HIS <: History[PMOD, SI, HIS]
-  type MS <: MinimalState[PMOD, MS]
-  type VL <: Vault[TX, PMOD, VL]
-  type MP <: MemoryPool[TX, MP]
+  type History <: consensus.History[PMOD, SI, History]
+  type State <: MinimalState[PMOD, State]
+  type Vault <: transaction.wallet.Vault[TX, PMOD, Vault]
+  type MPool <: MempoolReader[TX]
 
-  type NodeView = (HIS, MS, VL, MP)
+  /** State actor used for asynchronous transaction validation
+    */
+  protected val stateActor: ActorRef = createStateActor()
 
-  case class UpdateInformation(history: HIS,
-                               state: MS,
-                               failedMod: Option[PMOD],
-                               alternativeProgressInfo: Option[ProgressInfo[PMOD]],
-                               suffix: IndexedSeq[PMOD])
+  /** Underlying memory pool actor
+    */
+  protected val memoryPoolActor: ActorRef = createMemoryPoolActor()
+
+  protected var vault: Vault = restoreVault().getOrElse(genesisVault())
 
   val scorexSettings: ScorexSettings
 
-  /**
-    * Cache for modifiers. If modifiers are coming out-of-order, they are to be stored in this cache.
-    */
-  protected lazy val modifiersCache: ModifiersCache[PMOD, HIS] =
-    new DefaultModifiersCache[PMOD, HIS](scorexSettings.network.maxModifiersCacheSize)
-
-  /**
-    * The main data structure a node software is taking care about, a node view consists
-    * of four elements to be updated atomically: history (log of persistent modifiers),
-    * state (result of log's modifiers application to pre-historical(genesis) state,
-    * user-specific information stored in vault (it could be e.g. a wallet), and a memory pool.
+  protected implicit val defaultAskTimeout: Timeout = Timeout(10.seconds)
+  protected implicit val executionContext: ExecutionContext = context.dispatcher
+
+  /** Restore a local history during a node startup. If no any stored view found
+    * (e.g. if it is a first launch of a node) None is to be returned
     */
-  private var nodeView: NodeView = restoreState().getOrElse(genesisState)
+  protected def restoreHistory(): Option[History]
 
-  /**
-    * Restore a local view during a node startup. If no any stored view found
+  /** Restore a local state during a node startup. If no any stored view found
     * (e.g. if it is a first launch of a node) None is to be returned
     */
-  def restoreState(): Option[NodeView]
+  protected def restoreState(): Option[State]
 
-  /**
-    * Hard-coded initial view all the honest nodes in a network are making progress from.
+  /** Restore a local vault during a node startup. If no any stored view found
+    * (e.g. if it is a first launch of a node) None is to be returned
     */
-  protected def genesisState: NodeView
+  protected def restoreVault(): Option[Vault]
 
+  /** Restore a local memory pool during a node startup. If no any stored view found
+    * (e.g. if it is a first launch of a node) None is to be returned
+    */
+  protected def restoreMempool(): Option[MPool]
 
-  protected def history(): HIS = nodeView._1
+  /** Hard-coded initial history all the honest nodes in a network are making progress from
+    */
+  protected def genesisHistory(): History
 
-  protected def minimalState(): MS = nodeView._2
+  /** Hard-coded initial state all the honest nodes in a network are making progress from
+    */
+  protected def genesisState(): State
 
-  protected def vault(): VL = nodeView._3
+  /** Hard-coded initial state all the honest nodes in a network are making progress from
+    */
+  protected def genesisVault(): Vault
 
-  protected def memoryPool(): MP = nodeView._4
+  /** Hard-coded initial history all the honest nodes in a network are making progress from
+    */
+  protected def genesisMempool(): MPool
 
-  protected def txModify(tx: TX): Unit = {
-    //todo: async validation?
-    val errorOpt: Option[Throwable] = minimalState() match {
-      case txValidator: TransactionValidation[TX] =>
-        txValidator.validate(tx) match {
-          case Success(_) => None
-          case Failure(e) => Some(e)
-        }
-      case _ => None
-    }
+  protected def createMemoryPoolActor(): ActorRef
 
-    errorOpt match {
-      case None =>
-        memoryPool().put(tx) match {
-          case Success(newPool) =>
-            log.debug(s"Unconfirmed transaction $tx added to the memory pool")
-            val newVault = vault().scanOffchain(tx)
-            updateNodeView(updatedVault = Some(newVault), updatedMempool = Some(newPool))
-            context.system.eventStream.publish(SuccessfulTransaction[TX](tx))
-
-          case Failure(e) =>
-            context.system.eventStream.publish(FailedTransaction[TX](tx, e))
-        }
-
-      case Some(e) =>
-        context.system.eventStream.publish(FailedTransaction[TX](tx, e))
-    }
+  protected def createStateActor(): ActorRef = {
+    StateHistoryActor[TX, PMOD, SI, State, History](restoreState().getOrElse(genesisState()),
+      restoreHistory().getOrElse(genesisHistory()))(context.system)
   }
 
-  /**
-    * Update NodeView with new components and notify subscribers of changed components
-    *
-    * @param updatedHistory
-    * @param updatedState
-    * @param updatedVault
-    * @param updatedMempool
+  /** Cache for modifiers. If modifiers are coming out-of-order, they are to be stored in this cache.
     */
-  protected def updateNodeView(updatedHistory: Option[HIS] = None,
-                               updatedState: Option[MS] = None,
-                               updatedVault: Option[VL] = None,
-                               updatedMempool: Option[MP] = None): Unit = {
-    val newNodeView = (updatedHistory.getOrElse(history()),
-      updatedState.getOrElse(minimalState()),
-      updatedVault.getOrElse(vault()),
-      updatedMempool.getOrElse(memoryPool()))
-    if (updatedHistory.nonEmpty) {
-      context.system.eventStream.publish(ChangedHistory(newNodeView._1.getReader))
-    }
-    if (updatedState.nonEmpty) {
-      context.system.eventStream.publish(ChangedState(newNodeView._2.getReader))
-    }
-    if (updatedVault.nonEmpty) {
-      context.system.eventStream.publish(ChangedVault(newNodeView._3.getReader))
-    }
-    if (updatedMempool.nonEmpty) {
-      context.system.eventStream.publish(ChangedMempool(newNodeView._4.getReader))
-    }
-    nodeView = newNodeView
-  }
+  protected lazy val modifiersCache: ModifiersCache[PMOD, HistoryReader[PMOD, SI]] =
+    new DefaultModifiersCache[PMOD, HistoryReader[PMOD, SI]](scorexSettings.network.maxModifiersCacheSize)
 
   protected def extractTransactions(mod: PMOD): Seq[TX] = mod match {
     case tcm: TransactionsCarryingPersistentNodeViewModifier[TX] => tcm.transactions
     case _ => Seq()
   }
 
+  protected def processModifiers: Receive = {
+    case msg: ModifiersFromRemote[PMOD] => processRemoteModifiers(msg.modifiers)
+    case NextRemoteModifier(history) => nextRemoteModifier(history.asInstanceOf[HistoryReader[PMOD, SI]])
+    case msg: LocallyGeneratedModifier[PMOD] => processLocalModifier(msg.pmod)
+    case response: PersistentModifierResponse[PMOD] => persistentModifierResponse(response)
+  }
 
-  //todo: this method causes delays in a block processing as it removes transactions from mempool and checks
-  //todo: validity of remaining transactions in a synchronous way. Do this job async!
-  protected def updateMemPool(blocksRemoved: Seq[PMOD], blocksApplied: Seq[PMOD], memPool: MP, state: MS): MP = {
-    val rolledBackTxs = blocksRemoved.flatMap(extractTransactions)
+  protected def processLocalModifier(modifier: PMOD): Unit = {
+    log.info(s"Got locally generated modifier ${modifier.encodedId} of type ${modifier.modifierTypeId}")
+    stateActor ! ApplyModifier(modifier, LocallyGenerated)
+  }
 
-    val appliedTxs = blocksApplied.flatMap(extractTransactions)
+  /** Process new modifiers from remote.
+    * Put all candidates to modifiersCache and then try to apply as much modifiers from cache as possible.
+    * Clear cache if it's size exceeds size limit.
+    * Publish `ModifiersProcessingResult` message with all just applied and removed from cache modifiers.
+    */
+  protected def processRemoteModifiers(mods: Iterable[PMOD]): Unit = {
+    mods.foreach(m => modifiersCache.put(m.id, m))
+    log.debug(s"Cache size before: ${modifiersCache.size}")
+    sendReader[HistoryReader[PMOD, SI]](HistoryComponent) { r => self ! NextRemoteModifier(r) }
+  }
 
-    memPool.putWithoutCheck(rolledBackTxs).filter { tx =>
-      !appliedTxs.exists(t => t.id == tx.id) && {
-        state match {
-          case v: TransactionValidation[TX] => v.validate(tx).isSuccess
-          case _ => true
-        }
-      }
+  protected def nextRemoteModifier(history: HistoryReader[PMOD, SI]): Unit = {
+    modifiersCache.popCandidate(history) match {
+      case Some(mod) =>
+        stateActor ! ApplyModifier(mod, RemotelyGenerated)
+      case None =>
+        val cleared = modifiersCache.cleanOverfull()
+        log.debug(s"Cache size after application: ${modifiersCache.size}")
+        context.system.eventStream.publish(ModifiersProcessingResult(Seq.empty, cleared))
     }
   }
 
-  private def requestDownloads(pi: ProgressInfo[PMOD]): Unit =
-    pi.toDownload.foreach { case (tid, id) =>
-      context.system.eventStream.publish(DownloadRequest(tid, id))
+  @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
+  protected def persistentModifierResponse(response: PersistentModifierResponse[PMOD]): Unit = {
+    val PersistentModifierResponse(updatedComponents, progressInfo, blocksApplied, pmod, mode) = response
+    publishNodeView(updatedComponents)
+    if (updatedComponents.contains(HistoryComponent)) {
+      progressInfo.toDownload.foreach { case (tid, id) =>
+        context.system.eventStream.publish(DownloadRequest(tid, id))
+      }
+    }
+    if (updatedComponents.contains(StateComponent) &&  progressInfo.toApply.nonEmpty) {
+      updateMemPool(progressInfo.toRemove, blocksApplied)
+      if (progressInfo.chainSwitchingNeeded) {
+        //we consider that vault always able to perform a rollback needed
+        vault = vault.rollback(idToVersion(progressInfo.branchPoint.get)).get
+      }
+      blocksApplied.foreach(vault.scanPersistent)
+      context.system.eventStream.publish(ChangedVault(vault.getReader))
+      publishNodeView(Set(VaultComponent, MempoolComponent))
+    }
+    if (mode == RemotelyGenerated) {
+      context.system.eventStream.publish(ModifiersProcessingResult(Seq(pmod), Seq.empty))
+      sendReader[HistoryReader[PMOD, SI]](HistoryComponent) { r => self ! NextRemoteModifier(r) }
     }
+  }
 
-  private def trimChainSuffix(suffix: IndexedSeq[PMOD], rollbackPoint: scorex.util.ModifierId): IndexedSeq[PMOD] = {
-    val idx = suffix.indexWhere(_.id == rollbackPoint)
-    if (idx == -1) IndexedSeq() else suffix.drop(idx)
+  protected def updateMemPool(blocksRemoved: Seq[PMOD], blocksApplied: Seq[PMOD]): Unit = {
+    val rolledBackTxs = blocksRemoved.flatMap(extractTransactions)
+    val appliedTxs = blocksApplied.flatMap(extractTransactions)
+    val appliedIds = appliedTxs.map(_.id).toSet
+    val txsToPut = rolledBackTxs.filterNot(tx => appliedIds.contains(tx.id))
+    txsToPut.foreach(tx => stateActor ! ValidateTransaction(tx, PutWithoutCheck))
   }
 
-  /**
-
-    Assume that history knows the following blocktree:
-
-           G
-          / \
-         *   G
-        /     \
-       *       G
-
-    where path with G-s is about canonical chain (G means semantically valid modifier), path with * is sidechain (* means
-    that semantic validity is unknown). New modifier is coming to the sidechain, it sends rollback to the root +
-    application of the sidechain to the state. Assume that state is finding that some modifier in the sidechain is
-    incorrect:
-
-           G
-          / \
-         G   G
-        /     \
-       B       G
-      /
-     *
-
-    In this case history should be informed about the bad modifier and it should retarget state
-
-    //todo: improve the comment below
-
-    We assume that we apply modifiers sequentially (on a single modifier coming from the network or generated locally),
-    and in case of failed application of some modifier in a progressInfo, rollback point in an alternative should be not
-    earlier than a rollback point of an initial progressInfo.
-   **/
-
-  @tailrec
-  private def updateState(history: HIS,
-                          state: MS,
-                          progressInfo: ProgressInfo[PMOD],
-                          suffixApplied: IndexedSeq[PMOD]): (HIS, Try[MS], Seq[PMOD]) = {
-    requestDownloads(progressInfo)
-
-    val (stateToApplyTry: Try[MS], suffixTrimmed: IndexedSeq[PMOD]) = if (progressInfo.chainSwitchingNeeded) {
-        @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-        val branchingPoint = progressInfo.branchPoint.get //todo: .get
-        if (state.version != branchingPoint) {
-          state.rollbackTo(idToVersion(branchingPoint)) -> trimChainSuffix(suffixApplied, branchingPoint)
-        } else Success(state) -> IndexedSeq()
-    } else Success(state) -> suffixApplied
-
-    stateToApplyTry match {
-      case Success(stateToApply) =>
-        val stateUpdateInfo = applyState(history, stateToApply, suffixTrimmed, progressInfo)
-
-        stateUpdateInfo.failedMod match {
-          case Some(_) =>
-            @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-            val alternativeProgressInfo = stateUpdateInfo.alternativeProgressInfo.get
-            updateState(stateUpdateInfo.history, stateUpdateInfo.state, alternativeProgressInfo, stateUpdateInfo.suffix)
-          case None => (stateUpdateInfo.history, Success(stateUpdateInfo.state), stateUpdateInfo.suffix)
-        }
-      case Failure(e) =>
-        log.error("Rollback failed: ", e)
-        context.system.eventStream.publish(RollbackFailed)
-        //todo: what to return here? the situation is totally wrong
-        ???
-    }
+  protected def processNewTransactions: Receive = {
+    case newTxs: NewTransactions[TX] => txModify(newTxs.txs)
+    case validationResponse: TransactionValidationResponse[TX] => txValidationResponse(validationResponse)
+    case putResponse: PutResponse[TX] => txPutResponse(putResponse)
   }
 
-  protected def applyState(history: HIS,
-                           stateToApply: MS,
-                           suffixTrimmed: IndexedSeq[PMOD],
-                           progressInfo: ProgressInfo[PMOD]): UpdateInformation = {
-    val updateInfoSample = UpdateInformation(history, stateToApply, None, None, suffixTrimmed)
-    progressInfo.toApply.foldLeft(updateInfoSample) { case (updateInfo, modToApply) =>
-      if (updateInfo.failedMod.isEmpty) {
-        updateInfo.state.applyModifier(modToApply) match {
-          case Success(stateAfterApply) =>
-            val newHis = history.reportModifierIsValid(modToApply)
-            context.system.eventStream.publish(SemanticallySuccessfulModifier(modToApply))
-            UpdateInformation(newHis, stateAfterApply, None, None, updateInfo.suffix :+ modToApply)
-          case Failure(e) =>
-            val (newHis, newProgressInfo) = history.reportModifierIsInvalid(modToApply, progressInfo)
-            context.system.eventStream.publish(SemanticallyFailedModification(modToApply, e))
-            UpdateInformation(newHis, updateInfo.state, Some(modToApply), Some(newProgressInfo), updateInfo.suffix)
-        }
-      } else updateInfo
-    }
+  protected def txModify(txs: Iterable[TX]): Unit = {
+    txs.foreach(tx => stateActor ! ValidateTransaction(tx))
   }
 
-  //todo: update state in async way?
-  protected def pmodModify(pmod: PMOD): Unit =
-    if (!history().contains(pmod.id)) {
-      context.system.eventStream.publish(StartingPersistentModifierApplication(pmod))
-
-      log.info(s"Apply modifier ${pmod.encodedId} of type ${pmod.modifierTypeId} to nodeViewHolder")
-
-      history().append(pmod) match {
-        case Success((historyBeforeStUpdate, progressInfo)) =>
-          log.debug(s"Going to apply modifications to the state: $progressInfo")
-          context.system.eventStream.publish(SyntacticallySuccessfulModifier(pmod))
-          context.system.eventStream.publish(NewOpenSurface(historyBeforeStUpdate.openSurfaceIds()))
-
-          if (progressInfo.toApply.nonEmpty) {
-            val (newHistory, newStateTry, blocksApplied) =
-              updateState(historyBeforeStUpdate, minimalState(), progressInfo, IndexedSeq())
-
-            newStateTry match {
-              case Success(newMinState) =>
-                val newMemPool = updateMemPool(progressInfo.toRemove, blocksApplied, memoryPool(), newMinState)
-
-                //we consider that vault always able to perform a rollback needed
-                @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-                val newVault = if (progressInfo.chainSwitchingNeeded) {
-                  vault().rollback(idToVersion(progressInfo.branchPoint.get)).get
-                } else vault()
-                blocksApplied.foreach(newVault.scanPersistent)
-
-                log.info(s"Persistent modifier ${pmod.encodedId} applied successfully")
-                updateNodeView(Some(newHistory), Some(newMinState), Some(newVault), Some(newMemPool))
-
-
-              case Failure(e) =>
-                log.warn(s"Can`t apply persistent modifier (id: ${pmod.encodedId}, contents: $pmod) to minimal state", e)
-                updateNodeView(updatedHistory = Some(newHistory))
-                context.system.eventStream.publish(SemanticallyFailedModification(pmod, e))
-            }
-          } else {
-            requestDownloads(progressInfo)
-            updateNodeView(updatedHistory = Some(historyBeforeStUpdate))
-          }
-        case Failure(e) =>
-          log.warn(s"Can`t apply persistent modifier (id: ${pmod.encodedId}, contents: $pmod) to history", e)
-          context.system.eventStream.publish(SyntacticallyFailedModification(pmod, e))
-      }
-    } else {
-      log.warn(s"Trying to apply modifier ${pmod.encodedId} that's already in history")
+  protected def txValidationResponse(response: TransactionValidationResponse[TX]): Unit = {
+    response match {
+      case TransactionValidationResponse(tx, Success(()), mode) =>
+        memoryPoolActor ! Put(tx, mode)
+
+      case TransactionValidationResponse(tx, Failure(e), _) =>
+        context.system.eventStream.publish(FailedTransaction[TX](tx, e))
     }
+  }
 
-  /**
-    * Process new modifiers from remote.
-    * Put all candidates to modifiersCache and then try to apply as much modifiers from cache as possible.
-    * Clear cache if it's size exceeds size limit.
-    * Publish `ModifiersProcessingResult` message with all just applied and removed from cache modifiers.
-    */
-  protected def processRemoteModifiers: Receive = {
-    case ModifiersFromRemote(mods: Seq[PMOD]) =>
-      mods.foreach(m => modifiersCache.put(m.id, m))
-
-      log.debug(s"Cache size before: ${modifiersCache.size}")
-
-      @tailrec
-      def applyLoop(applied: Seq[PMOD]): Seq[PMOD] = {
-        modifiersCache.popCandidate(history()) match {
-          case Some(mod) =>
-            pmodModify(mod)
-            applyLoop(mod +: applied)
-          case None =>
-            applied
-        }
-      }
+  protected def txPutResponse(response: PutResponse[TX]): Unit = response match {
+    case PutResponse(_, _, PutWithoutCheck) =>
+    //ignore
 
-      val applied = applyLoop(Seq())
-      val cleared = modifiersCache.cleanOverfull()
+    case PutResponse(tx, Failure(e), _) =>
+      context.system.eventStream.publish(FailedTransaction[TX](tx, e))
 
-      context.system.eventStream.publish(ModifiersProcessingResult(applied, cleared))
-      log.debug(s"Cache size after: ${modifiersCache.size}")
+    case PutResponse(tx, Success(()), _) =>
+      log.debug(s"Unconfirmed transactions $tx added to the memory pool")
+      context.system.eventStream.publish(SuccessfulTransaction(tx))
+      vault = vault.scanOffchain(tx)
+      context.system.eventStream.publish(ChangedVault(vault.getReader))
+      publishNodeView(Set(MempoolComponent, VaultComponent))
   }
 
-  protected def processNewTransactions: Receive = {
-    case newTxs: NewTransactions[TX] =>
-      newTxs.txs.foreach(tx => txModify(tx))
+  /** Request current node view and perform small transformation with it;
+    * `callback` should be a lightweight lambda operation to transform result
+    * and it should not access any actor's state.
+    */
+  protected def getCurrentInfo: Receive = {
+    case GetDataFromCurrentView(f) =>
+      val callback = sender
+      for {
+        historyReader <- getReaderFuture(HistoryComponent)
+        stateReader <- getReaderFuture(StateComponent)
+        mempoolReader <- getReaderFuture(MempoolComponent)
+      } yield callback ! f(CurrentView(historyReader, stateReader, vault, mempoolReader))
   }
 
-  protected def processLocallyGeneratedModifiers: Receive = {
-    case lm: LocallyGeneratedModifier[PMOD] =>
-      log.info(s"Got locally generated modifier ${lm.pmod.encodedId} of type ${lm.pmod.modifierTypeId}")
-      pmodModify(lm.pmod)
+  protected def getNodeViewChanges: Receive = {
+    case GetNodeViewChanges(components) =>
+      val callback = sender
+      components.foreach { c => sendChangeEvent(c)(e => callback ! e) }
   }
 
-  protected def getCurrentInfo: Receive = {
-    case GetDataFromCurrentView(f) =>
-      sender() ! f(CurrentView(history(), minimalState(), vault(), memoryPool()))
+  protected def publishNodeView(components: Set[ComponentType]): Unit = {
+    components.foreach { c => sendChangeEvent(c)(e => context.system.eventStream.publish(e)) }
   }
 
-  protected def getNodeViewChanges: Receive = {
-    case GetNodeViewChanges(history, state, vault, mempool) =>
-      if (history) sender() ! ChangedHistory(nodeView._1.getReader)
-      if (state) sender() ! ChangedState(nodeView._2.getReader)
-      if (vault) sender() ! ChangedVault(nodeView._3.getReader)
-      if (mempool) sender() ! ChangedMempool(nodeView._4.getReader)
+
+  /** Send component reader by performing small operation with it (e.g. actor tell, or eventStream publish);
+    * `callback` should not be a heavy operation and it SHOULD NOT UPDATE ANY STATE.
+    * @param componentType type of the component to get the reader
+    * @param callback lightweight lambda, it shouldn't access any actor's state
+    */
+  protected def sendReader[C <: NodeViewComponent : ClassTag](componentType: ComponentType)
+                                                             (callback: C => Unit): Unit = {
+    getReaderFuture(HistoryComponent).mapTo[C].onComplete {
+      case Success(r) => callback(r)
+      case Failure(e) => log.error(s"Failed to get $toString reader: ${e.getMessage}", e)
+    }
+  }
+
+  /** Send change event by performing small operation with it (e.g. actor tell, or eventStream publish);
+    * `callback` should not be a heavy operation and it SHOULD NOT UPDATE ANY STATE.
+    * @param componentType type of the component to get the reader
+    * @param callback lightweight lambda, it shouldn't access any actor's state
+    */
+  protected def sendChangeEvent(componentType: ComponentType)(callback: NodeViewChange => Unit): Unit = {
+    componentType match {
+      case HistoryComponent => sendReader[HistoryReader[PMOD, SI]](MempoolComponent)(r => callback(ChangedHistory(r)))
+      case StateComponent => sendReader[StateReader](MempoolComponent)(r => callback(ChangedState(r)))
+      case VaultComponent => sendReader[VaultReader](MempoolComponent)(r => callback(ChangedVault(r)))
+      case MempoolComponent => sendReader[MempoolReader[TX]](MempoolComponent)(r => callback(ChangedMempool(r)))
+    }
+  }
+
+  def getReaderFuture(componentType: ComponentType): Future[Any] = componentType match {
+    case HistoryComponent => stateActor ? GetReader(componentType)
+    case StateComponent => stateActor ? GetReader(componentType)
+    case VaultComponent => Future.successful(vault.getReader)
+    case MempoolComponent => memoryPoolActor ? GetReader(componentType)
   }
 
   override def receive: Receive =
-    processRemoteModifiers orElse
-      processLocallyGeneratedModifiers orElse
+    processModifiers orElse
       processNewTransactions orElse
       getCurrentInfo orElse
       getNodeViewChanges orElse {
@@ -374,20 +282,24 @@ trait NodeViewHolder[TX <: Transaction, PMOD <: PersistentNodeViewModifier]
     }
 }
 
-
 object NodeViewHolder {
 
   object ReceivableMessages {
 
     // Explicit request of NodeViewChange events of certain types.
-    case class GetNodeViewChanges(history: Boolean, state: Boolean, vault: Boolean, mempool: Boolean)
+    case class GetNodeViewChanges(components: Set[ComponentType])
 
-    case class GetDataFromCurrentView[HIS, MS, VL, MP, A](f: CurrentView[HIS, MS, VL, MP] => A)
+    /**  Request current node view and perform small transformation with it;
+      * `callback` should not be a heavy operation  and it should not access any actor's state.
+      *
+      * @param callback lightweight lambda to transform result, it shouldn't access any actor's state
+      */
+    case class GetDataFromCurrentView[HIS, State, Vault, MPool, A](callback: CurrentView[HIS, State, Vault, MPool] => A)
 
     // Modifiers received from the remote peer with new elements in it
     case class ModifiersFromRemote[PM <: PersistentNodeViewModifier](modifiers: Iterable[PM])
 
-    sealed trait NewTransactions[TX <: Transaction]{
+    sealed trait NewTransactions[TX <: Transaction] {
       val txs: Iterable[TX]
     }
 
@@ -399,6 +311,8 @@ object NodeViewHolder {
 
     case class LocallyGeneratedModifier[PMOD <: PersistentNodeViewModifier](pmod: PMOD)
 
+    case class NextRemoteModifier[H <: HistoryReader[_, _]](history: H)
+
   }
 
   // fixme: No actor is expecting this ModificationApplicationStarted and DownloadRequest messages
diff --git a/src/main/scala/scorex/core/api/http/NodeViewApiRoute.scala b/src/main/scala/scorex/core/api/http/NodeViewApiRoute.scala
index 37260a7e7..b8e718695 100644
--- a/src/main/scala/scorex/core/api/http/NodeViewApiRoute.scala
+++ b/src/main/scala/scorex/core/api/http/NodeViewApiRoute.scala
@@ -5,14 +5,14 @@ import akka.http.scaladsl.server.Route
 import akka.pattern.ask
 import io.circe.syntax._
 import scorex.core.NodeViewHolder.CurrentView
+import scorex.core.PersistentNodeViewModifier
 import scorex.core.consensus.History
 import scorex.core.serialization.SerializerRegistry
 import scorex.core.settings.RESTApiSettings
 import scorex.core.transaction.state.MinimalState
 import scorex.core.transaction.wallet.Vault
-import scorex.core.transaction.{MemoryPool, Transaction}
+import scorex.core.transaction.{MempoolReader, Transaction}
 import scorex.core.utils.ScorexEncoding
-import scorex.core.PersistentNodeViewModifier
 import scorex.util.{ModifierId, bytesToId}
 
 import scala.concurrent.ExecutionContext
@@ -33,7 +33,7 @@ case class NodeViewApiRoute[TX <: Transaction]
 
   type PM <: PersistentNodeViewModifier
   type HIS <: History[PM, _, _ <: History[PM, _, _]]
-  type MP <: MemoryPool[TX, _ <: MemoryPool[TX, _]]
+  type MP <: MempoolReader[TX]
   type MS <: MinimalState[PM, _ <: MinimalState[_, _]]
   type VL <: Vault[TX, PM, _ <: Vault[TX, PM, _]]
 
diff --git a/src/main/scala/scorex/core/consensus/History.scala b/src/main/scala/scorex/core/consensus/History.scala
index 58d2dbfe8..6d29e7db2 100644
--- a/src/main/scala/scorex/core/consensus/History.scala
+++ b/src/main/scala/scorex/core/consensus/History.scala
@@ -94,4 +94,10 @@ object History {
     }
   }
 
+  object ProgressInfo {
+    def empty[PM <: PersistentNodeViewModifier](implicit encoder: ScorexEncoder): ProgressInfo[PM] = {
+      apply(None, Seq.empty, Seq.empty, Seq.empty)
+    }
+  }
+
 }
diff --git a/src/main/scala/scorex/core/network/NodeViewSynchronizer.scala b/src/main/scala/scorex/core/network/NodeViewSynchronizer.scala
index 9ee0b0684..52a5a0790 100644
--- a/src/main/scala/scorex/core/network/NodeViewSynchronizer.scala
+++ b/src/main/scala/scorex/core/network/NodeViewSynchronizer.scala
@@ -4,6 +4,7 @@ package scorex.core.network
 import java.net.InetSocketAddress
 
 import akka.actor.{Actor, ActorRef, ActorSystem, Props}
+import scorex.core.NodeViewComponent.{HistoryComponent, MempoolComponent}
 import scorex.core.NodeViewHolder.DownloadRequest
 import scorex.core.NodeViewHolder.ReceivableMessages.{GetNodeViewChanges, ModifiersFromRemote, TransactionsFromRemote}
 import scorex.core.consensus.History._
@@ -41,11 +42,11 @@ import scala.util.{Failure, Success}
   * @tparam SIS SyncInfoMessage specification
   */
 class NodeViewSynchronizer[TX <: Transaction,
-SI <: SyncInfo,
-SIS <: SyncInfoMessageSpec[SI],
-PMOD <: PersistentNodeViewModifier,
-HR <: HistoryReader[PMOD, SI] : ClassTag,
-MR <: MempoolReader[TX] : ClassTag]
+  SI <: SyncInfo,
+  SIS <: SyncInfoMessageSpec[SI],
+  PMOD <: PersistentNodeViewModifier,
+  HR <: HistoryReader[PMOD, SI] : ClassTag,
+  MR <: MempoolReader[TX] : ClassTag]
 (networkControllerRef: ActorRef,
  viewHolderRef: ActorRef,
  syncInfoSpec: SIS,
@@ -81,7 +82,7 @@ MR <: MempoolReader[TX] : ClassTag]
     context.system.eventStream.subscribe(self, classOf[ModificationOutcome])
     context.system.eventStream.subscribe(self, classOf[DownloadRequest])
     context.system.eventStream.subscribe(self, classOf[ModifiersProcessingResult[PMOD]])
-    viewHolderRef ! GetNodeViewChanges(history = true, state = false, vault = false, mempool = true)
+    viewHolderRef ! GetNodeViewChanges(Set(HistoryComponent, MempoolComponent))
 
     statusTracker.scheduleSendSyncInfo()
   }
diff --git a/src/main/scala/scorex/core/transaction/MemoryPool.scala b/src/main/scala/scorex/core/transaction/MemoryPool.scala
deleted file mode 100644
index 758752a9c..000000000
--- a/src/main/scala/scorex/core/transaction/MemoryPool.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-package scorex.core.transaction
-
-import scala.util.Try
-
-/**
-  * Unconfirmed transactions pool
-  *
-  * @tparam TX -type of transaction the pool contains
-  */
-trait MemoryPool[TX <: Transaction, M <: MemoryPool[TX, M]] extends MempoolReader[TX] {
-
-
-  /**
-    * Method to put a transaction into the memory pool. Validation of tha transactions against
-    * the state is done in NodeVieHolder. This put() method can check whether a transaction is valid
-    * @param tx
-    * @return Success(updatedPool), if transaction successfully added to the pool, Failure(_) otherwise
-    */
-  def put(tx: TX): Try[M]
-
-  def put(txs: Iterable[TX]): Try[M]
-
-  def putWithoutCheck(txs: Iterable[TX]): M
-
-  def remove(tx: TX): M
-
-  def filter(txs: Seq[TX]): M = filter(t => !txs.exists(_.id == t.id))
-
-  def filter(condition: TX => Boolean): M
-
-  /**
-    * @return read-only copy of this history
-    */
-  def getReader: MempoolReader[TX] = this
-}
\ No newline at end of file
diff --git a/src/main/scala/scorex/core/transaction/MempoolOperation.scala b/src/main/scala/scorex/core/transaction/MempoolOperation.scala
new file mode 100644
index 000000000..11a0252a5
--- /dev/null
+++ b/src/main/scala/scorex/core/transaction/MempoolOperation.scala
@@ -0,0 +1,45 @@
+package scorex.core.transaction
+
+import scorex.core.NodeViewComponentOperation
+import scorex.core.NodeViewComponentOperation.OperationMode
+
+import scala.util.Try
+
+/** Base trait for all memory pool operations, which should be sent to a memory pool actor
+  */
+trait MempoolOperation extends NodeViewComponentOperation
+
+/** Messages for the MemoryPool actor
+  */
+object MempoolOperation {
+
+  /** Put transactions into the memory pool. Validation of the transactions against
+    * the state is done in NodeViewHolder. This put() method can check whether a transaction is valid.
+    * Returns a `PutResponse`
+    */
+  case class Put[TX <: Transaction](transaction: TX, mode: OperationMode[Put[_]] = PutNormal)
+    extends MempoolOperation
+
+  /** Result of the `Put` operation. Should not be sent in `PutWithoutCheck` mode
+    */
+  case class PutResponse[TX <: Transaction](transaction: TX, result: Try[Unit], mode: OperationMode[Put[_]])
+
+  /** Remove transaction from memory pool
+    */
+  case class Remove[TX <: Transaction](transaction: TX) extends MempoolOperation
+
+  /** Remove transaction that complies criteria
+    */
+  case class FilterBy[TX <: Transaction](criteria: TX => Boolean)
+
+  /** Normal Put operation
+    */
+  object PutNormal extends OperationMode[Put[_]]
+
+  /** Memory pool should not send back the result of Put operation
+    */
+  object PutWithoutCheck extends OperationMode[Put[_]]{
+    def apply[TX <: Transaction](tx: TX): Put[TX] = Put(tx, PutWithoutCheck)
+  }
+
+}
diff --git a/src/main/scala/scorex/core/transaction/MempoolReader.scala b/src/main/scala/scorex/core/transaction/MempoolReader.scala
index 68c8db700..78341f3e5 100644
--- a/src/main/scala/scorex/core/transaction/MempoolReader.scala
+++ b/src/main/scala/scorex/core/transaction/MempoolReader.scala
@@ -4,19 +4,15 @@ import scorex.core.consensus.ContainsModifiers
 import scorex.core.NodeViewComponent
 import scorex.util.ModifierId
 
-/**
-  * Unconfirmed transactions pool
+/** Unconfirmed transactions pool reader
   *
-  * @tparam TX -type of transaction the pool contains
+  * @tparam TX - type of transaction the pool contains
   */
 trait MempoolReader[TX <: Transaction] extends NodeViewComponent with ContainsModifiers[TX] {
 
   //getters
   override def modifierById(modifierId: ModifierId): Option[TX]
 
-  @deprecated("use modifierById instead", "2018-08-14")
-  def getById(id: ModifierId): Option[TX] = modifierById(id)
-
   def contains(id: ModifierId): Boolean
 
   //get ids from Seq, not presenting in mempool
diff --git a/src/main/scala/scorex/core/transaction/ReferenceMempoolActor.scala b/src/main/scala/scorex/core/transaction/ReferenceMempoolActor.scala
new file mode 100644
index 000000000..1685be22c
--- /dev/null
+++ b/src/main/scala/scorex/core/transaction/ReferenceMempoolActor.scala
@@ -0,0 +1,72 @@
+package scorex.core.transaction
+
+import akka.actor.{Actor, ActorRef, ActorSystem, Props}
+import scorex.core.NodeViewComponent.MempoolComponent
+import scorex.core.NodeViewComponentOperation.GetReader
+import scorex.core.transaction.MempoolOperation._
+
+import scala.util.Try
+
+/** Trivial mempool implementation just for scratching purposes, not for real nodes. Bases on `ReferenceMempool`
+  */
+class ReferenceMempoolActor[TX <: Transaction, M <: ReferenceMempool[TX, M]](private var mempool: M) extends Actor {
+
+  def receive: Receive = put orElse remove orElse getReader
+
+  protected def put: Receive = {
+    case Put(tx, mode) if mode == PutWithoutCheck =>
+      mempool = mempool.putWithoutCheck(tx.asInstanceOf[TX])
+
+    case Put(tx, mode) =>
+      val result = mempool.put(tx.asInstanceOf[TX])
+      result.foreach(mempool = _)
+      sender ! PutResponse(tx, result.map(_ => ()), mode)
+  }
+
+  protected def remove: Receive = {
+    case Remove(tx) =>
+      mempool = mempool.remove(tx.asInstanceOf[TX])
+
+    case FilterBy(condition) =>
+      mempool = mempool.filterBy(condition.asInstanceOf[TX => Boolean])
+  }
+
+  protected def getReader: Receive = {
+    case GetReader(MempoolComponent) =>
+      val reader = mempool.getReader
+      sender ! reader
+  }
+}
+
+object ReferenceMempoolActor {
+
+  def props[TX <: Transaction, M <: ReferenceMempool[TX, M]](mempool: M): Props = {
+    Props(new ReferenceMempoolActor[TX, M](mempool))
+  }
+
+  def apply[TX <: Transaction, M <: ReferenceMempool[TX, M]](mempool: M)(implicit system: ActorSystem): ActorRef = {
+    system.actorOf(props[TX, M](mempool))
+  }
+}
+
+/** Trivial mempool interface, mostly for backward compatibility with old `MemoryPool` trait
+  * @tparam TX - type of transactions that the pool contains
+  */
+trait ReferenceMempool[TX <: Transaction, M <: ReferenceMempool[TX, M]] extends MempoolReader[TX] {
+
+  /** Method to put a transaction into the memory pool. Validation of tha transactions against
+    * the state is done in NodeVieHolder. This put() method can check whether a transaction is valid
+    * @return Success(updatedPool), if transaction successfully added to the pool, or Failure otherwise
+    */
+  def put(tx: TX): Try[M]
+
+  def putWithoutCheck(tx: TX): M
+
+  def remove(tx: TX): M
+
+  def filterBy(condition: TX => Boolean): M
+
+  /** Get the reader for the memory pool
+    */
+  def getReader: MempoolReader[TX] = this
+}
diff --git a/src/main/scala/scorex/core/transaction/state/MinimalState.scala b/src/main/scala/scorex/core/transaction/state/MinimalState.scala
index 0dba9b06c..484836da4 100644
--- a/src/main/scala/scorex/core/transaction/state/MinimalState.scala
+++ b/src/main/scala/scorex/core/transaction/state/MinimalState.scala
@@ -9,15 +9,14 @@ import scala.util.Try
 /**
   * Abstract functional interface of state which is a result of a sequential blocks applying
   */
-trait MinimalState[M <: PersistentNodeViewModifier, MS <: MinimalState[M, MS]] extends StateReader {
-  self: MS =>
+trait MinimalState[M <: PersistentNodeViewModifier, State <: MinimalState[M, State]] extends StateReader {
+  self: State =>
 
-  def applyModifier(mod: M): Try[MS]
+  def applyModifier(mod: M): Try[State]
 
-  def rollbackTo(version: VersionTag): Try[MS]
+  def rollbackTo(version: VersionTag): Try[State]
 
-  /**
-    * @return read-only copy of this state
+  /** read-only copy of this state
     */
   def getReader: StateReader = this
 
diff --git a/src/main/scala/scorex/core/transaction/state/StateHistoryActor.scala b/src/main/scala/scorex/core/transaction/state/StateHistoryActor.scala
new file mode 100644
index 000000000..33be28ed0
--- /dev/null
+++ b/src/main/scala/scorex/core/transaction/state/StateHistoryActor.scala
@@ -0,0 +1,222 @@
+package scorex.core.transaction.state
+
+import akka.actor.{Actor, ActorRef, ActorSystem, Props}
+import scorex.core.NodeViewComponent.{HistoryComponent, StateComponent}
+import scorex.core.NodeViewComponentOperation.{GetReader, OperationMode}
+import scorex.core.consensus.History.ProgressInfo
+import scorex.core.consensus.SyncInfo
+import scorex.core.network.NodeViewSynchronizer.ReceivableMessages._
+import scorex.core.transaction.Transaction
+import scorex.core.transaction.state.StateOperation._
+import scorex.core.utils.ScorexEncoding
+import scorex.core.{PersistentNodeViewModifier, consensus, idToVersion}
+import scorex.util.ScorexLogging
+
+import scala.annotation.tailrec
+import scala.util.{Failure, Success, Try}
+
+class StateHistoryActor[TX <: Transaction,
+    PMOD <: PersistentNodeViewModifier,
+    SI <: SyncInfo,
+    State <: MinimalState[PMOD, State],
+    History <: consensus.History[PMOD, SI, History]
+](private var state: State, private var history: History)
+  extends Actor with ScorexLogging with ScorexEncoding {
+
+  def receive: Receive = applyModifier orElse getReader orElse validate
+
+  val applyModifier: Receive = {
+    case ApplyModifier(modifier, mode) =>
+      val result = applyPersistentModifier(modifier.asInstanceOf[PMOD], mode)
+      sender ! result
+  }
+
+  val getReader: Receive = {
+    case GetReader(StateComponent) =>
+      val reader = state.getReader
+      sender ! reader
+    case GetReader(HistoryComponent) =>
+      val reader = history.getReader
+      sender ! reader
+  }
+
+  val validate: Receive = {
+    case request: ValidateTransaction[TX] =>
+      val response = txValidation(request)
+      sender ! response
+  }
+
+  private def txValidation(request: ValidateTransaction[TX]): TransactionValidationResponse[TX] = {
+    val ValidateTransaction(tx, mode) = request
+    state match {
+      case txValidator: TransactionValidation[TX] =>
+        TransactionValidationResponse(tx, txValidator.validate(tx), mode)
+
+      case _ =>
+        TransactionValidationResponse(tx, Success(()), mode)
+    }
+  }
+
+  protected def applyPersistentModifier(pmod: PMOD,
+                                        mode: OperationMode[ApplyModifier[_]]): PersistentModifierResponse[PMOD] = {
+    if (history.contains(pmod.id)) {
+      log.warn(s"Trying to apply modifier ${pmod.encodedId} that's already in history")
+      PersistentModifierResponse(Set.empty, ProgressInfo.empty, Seq.empty, pmod, mode)
+    } else {
+      context.system.eventStream.publish(StartingPersistentModifierApplication(pmod))
+      log.info(s"Apply modifier ${pmod.encodedId} of type ${pmod.modifierTypeId} to nodeViewHolder")
+      history.append(pmod) match {
+        case Failure(e) =>
+          log.warn(s"Can`t apply persistent modifier (id: ${pmod.encodedId}, contents: $pmod) to history", e)
+          context.system.eventStream.publish(SyntacticallyFailedModification(pmod, e))
+          PersistentModifierResponse(Set.empty, ProgressInfo.empty, Seq.empty, pmod, mode)
+        case Success((historyBeforeStUpdate, progressInfo)) =>
+          log.debug(s"Going to apply modifications to the state: $progressInfo")
+          context.system.eventStream.publish(SyntacticallySuccessfulModifier(pmod))
+          context.system.eventStream.publish(NewOpenSurface(historyBeforeStUpdate.openSurfaceIds()))
+          if (progressInfo.toApply.isEmpty) {
+            setHistory(historyBeforeStUpdate)
+            PersistentModifierResponse(Set(HistoryComponent), progressInfo, Seq.empty, pmod, mode)
+          } else {
+            updateState(historyBeforeStUpdate, state, progressInfo, IndexedSeq()) match {
+              case Success(UpdateInformation(newHistory, newState, _, _, suffix)) =>
+                log.info(s"Persistent modifier ${pmod.encodedId} applied successfully")
+                setHistory(newHistory)
+                setState(newState)
+                PersistentModifierResponse(Set(HistoryComponent, StateComponent), progressInfo, suffix, pmod, mode)
+              case Failure(e) =>
+                log.warn(s"Can`t apply persistent modifier (id: ${pmod.encodedId}, contents: $pmod) " +
+                                  s"to minimal state", e)
+                context.system.eventStream.publish(SemanticallyFailedModification(pmod, e))
+                PersistentModifierResponse(Set.empty, progressInfo, Seq.empty, pmod, mode)
+            }
+          }
+      }
+    }
+  }
+
+  /**
+  Assume that history knows the following blocktree:
+    {{{
+           G
+          / \
+      *   G
+        /     \
+      *       G
+    }}}
+    where path with G-s is about canonical chain (G means semantically valid modifier), path with * is sidechain (* means
+    that semantic validity is unknown). New modifier is coming to the sidechain, it sends rollback to the root +
+    application of the sidechain to the state. Assume that state is finding that some modifier in the sidechain is
+    incorrect:
+    {{{
+           G
+          / \
+         G   G
+        /     \
+       B       G
+      /
+      *
+    }}}
+    In this case history should be informed about the bad modifier and it should retarget state
+
+    //todo: improve the comment below
+
+    We assume that we apply modifiers sequentially (on a single modifier coming from the network or generated locally),
+    and in case of failed application of some modifier in a progressInfo, rollback point in an alternative should be not
+    earlier than a rollback point of an initial progressInfo.
+    **/
+  @tailrec
+  private def updateState(history: History,
+                          state: State,
+                          progressInfo: ProgressInfo[PMOD],
+                          suffixApplied: IndexedSeq[PMOD]): Try[UpdateInformation] = {
+
+    val (stateToApplyTry: Try[State], suffixTrimmed: IndexedSeq[PMOD]) = if (progressInfo.chainSwitchingNeeded) {
+      @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
+      val branchingPoint = progressInfo.branchPoint.get //todo: .get
+      if (state.version != branchingPoint) {
+        state.rollbackTo(idToVersion(branchingPoint)) -> trimChainSuffix(suffixApplied, branchingPoint)
+      } else Success(state) -> IndexedSeq()
+    } else Success(state) -> suffixApplied
+
+    stateToApplyTry match {
+      case Success(stateToApply) =>
+        val stateUpdateInfo = applyState(history, stateToApply, suffixTrimmed, progressInfo)
+
+        stateUpdateInfo.failedMod match {
+          case Some(_) =>
+            @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
+            val alternativeProgressInfo = stateUpdateInfo.alternativeProgressInfo.get
+            updateState(stateUpdateInfo.history, stateUpdateInfo.state, alternativeProgressInfo, stateUpdateInfo.suffix)
+          case None => Success(stateUpdateInfo)
+        }
+      case Failure(e) =>
+        log.error("Rollback failed: ", e)
+        context.system.eventStream.publish(RollbackFailed)
+        //todo: what to return here? the situation is totally wrong
+        ???
+    }
+  }
+
+  protected def applyState(history: History,
+                           stateToApply: State,
+                           suffixTrimmed: IndexedSeq[PMOD],
+                           progressInfo: ProgressInfo[PMOD]): UpdateInformation = {
+    val updateInfoSample = UpdateInformation(history, stateToApply, None, None, suffixTrimmed)
+    progressInfo.toApply.foldLeft(updateInfoSample) { case (updateInfo, modToApply) =>
+      if (updateInfo.failedMod.isEmpty) {
+        updateInfo.state.applyModifier(modToApply) match {
+          case Success(stateAfterApply) =>
+            val newHis = history.reportModifierIsValid(modToApply)
+            context.system.eventStream.publish(SemanticallySuccessfulModifier(modToApply))
+            UpdateInformation(newHis, stateAfterApply, None, None, updateInfo.suffix :+ modToApply)
+          case Failure(e) =>
+            val (newHis, newProgressInfo) = history.reportModifierIsInvalid(modToApply, progressInfo)
+            context.system.eventStream.publish(SemanticallyFailedModification(modToApply, e))
+            UpdateInformation(newHis, updateInfo.state, Some(modToApply), Some(newProgressInfo), updateInfo.suffix)
+        }
+      } else updateInfo
+    }
+  }
+
+  private def trimChainSuffix(suffix: IndexedSeq[PMOD], rollbackPoint: scorex.util.ModifierId): IndexedSeq[PMOD] = {
+    val idx = suffix.indexWhere(_.id == rollbackPoint)
+    if (idx == -1) IndexedSeq() else suffix.drop(idx)
+  }
+
+  private def setState(newState: State): Unit = {
+    state = newState
+  }
+
+  private def setHistory(newHistory: History): Unit = {
+    history = newHistory
+  }
+
+  case class UpdateInformation(history: History,
+                               state: State,
+                               failedMod: Option[PMOD],
+                               alternativeProgressInfo: Option[ProgressInfo[PMOD]],
+                               suffix: IndexedSeq[PMOD])
+
+}
+
+
+object StateHistoryActor {
+
+  def props[TX <: Transaction,
+  PMOD <: PersistentNodeViewModifier,
+  SI <: SyncInfo,
+  State <: MinimalState[PMOD, State],
+  History <: consensus.History[PMOD, SI, History]](state: State, history: History): Props = {
+    Props(new StateHistoryActor[TX, PMOD, SI, State, History](state, history))
+  }
+
+  def apply[TX <: Transaction,
+  PMOD <: PersistentNodeViewModifier,
+  SI <: SyncInfo,
+  State <: MinimalState[PMOD, State],
+  History <: consensus.History[PMOD, SI, History]](state: State, history: History)
+                                                  (implicit system: ActorSystem): ActorRef = {
+    system.actorOf(props[TX, PMOD, SI, State, History](state, history))
+  }
+}
diff --git a/src/main/scala/scorex/core/transaction/state/StateOperation.scala b/src/main/scala/scorex/core/transaction/state/StateOperation.scala
new file mode 100644
index 000000000..1ad559e51
--- /dev/null
+++ b/src/main/scala/scorex/core/transaction/state/StateOperation.scala
@@ -0,0 +1,46 @@
+package scorex.core.transaction.state
+
+import scorex.core.NodeViewComponent.ComponentType
+import scorex.core.NodeViewComponentOperation.OperationMode
+import scorex.core.consensus.History.ProgressInfo
+import scorex.core.transaction.MempoolOperation.{Put, PutNormal}
+import scorex.core.transaction.Transaction
+import scorex.core.{NodeViewComponentOperation, PersistentNodeViewModifier}
+
+import scala.util.Try
+
+trait StateOperation extends NodeViewComponentOperation
+
+object StateOperation {
+
+  /** Update state, actor responds with `UpdateStateResponse`
+    */
+  case class ApplyModifier[PMOD <: PersistentNodeViewModifier](pmod: PMOD, mode: OperationMode[ApplyModifier[_]])
+    extends StateOperation
+
+  /** Result of `UpdateState` operation
+    */
+  case class PersistentModifierResponse[PMOD <: PersistentNodeViewModifier](updatedComponents: Set[ComponentType],
+                                                                            progressInfo: ProgressInfo[PMOD],
+                                                                            blocksApplied: Seq[PMOD],
+                                                                            pmod: PMOD,
+                                                                            mode: OperationMode[ApplyModifier[_]])
+
+  /** Validation request, actor responds with `ValidationResponse`
+    *
+    * @param transaction transaction to validate
+    * @param putMode     optional info to pass back to sender together with the validation result.
+    *                    Is not checked during validation
+    */
+  case class ValidateTransaction[TX <: Transaction](transaction: TX, putMode: OperationMode[Put[_]] = PutNormal)
+
+  /** Result of `ValidateTransaction` operation
+    */
+  case class TransactionValidationResponse[TX <: Transaction](transaction: TX,
+                                                              validationResult: Try[Unit],
+                                                              putMode: OperationMode[Put[_]])
+
+  object LocallyGenerated extends OperationMode[ApplyModifier[_]]
+  object RemotelyGenerated extends OperationMode[ApplyModifier[_]]
+
+}
diff --git a/src/main/scala/scorex/core/transaction/wallet/Vault.scala b/src/main/scala/scorex/core/transaction/wallet/Vault.scala
index 4b4d4e076..36bb5af9a 100644
--- a/src/main/scala/scorex/core/transaction/wallet/Vault.scala
+++ b/src/main/scala/scorex/core/transaction/wallet/Vault.scala
@@ -24,9 +24,8 @@ trait Vault[TX <: Transaction, PMOD <: PersistentNodeViewModifier, V <: Vault[TX
 
   def rollback(to: VersionTag): Try[V]
 
-  /**
-    * @return read-only copy of this state
+  /** read-only copy of this state
     */
   def getReader: VaultReader = this
 
-}
\ No newline at end of file
+}
diff --git a/testkit/src/main/scala/scorex/testkit/BlockchainPerformance.scala b/testkit/src/main/scala/scorex/testkit/BlockchainPerformance.scala
index e18991375..46b482f42 100644
--- a/testkit/src/main/scala/scorex/testkit/BlockchainPerformance.scala
+++ b/testkit/src/main/scala/scorex/testkit/BlockchainPerformance.scala
@@ -2,18 +2,16 @@ package scorex.testkit
 
 import scorex.core.PersistentNodeViewModifier
 import scorex.core.consensus.{History, SyncInfo}
-import scorex.core.transaction.box.proposition.Proposition
+import scorex.core.transaction.Transaction
 import scorex.core.transaction.state.MinimalState
-import scorex.core.transaction.{MemoryPool, Transaction}
 import scorex.testkit.properties.mempool.MempoolFilterPerformanceTest
 
 /**
   * Performance test for implementations
   */
-trait BlockchainPerformance[
-TX <: Transaction,
-PM <: PersistentNodeViewModifier,
-SI <: SyncInfo,
-MPool <: MemoryPool[TX, MPool],
-ST <: MinimalState[PM, ST],
-HT <: History[PM, SI, HT]] extends MempoolFilterPerformanceTest[TX, MPool]
+trait BlockchainPerformance[TX <: Transaction,
+    PM <: PersistentNodeViewModifier,
+    SI <: SyncInfo,
+    ST <: MinimalState[PM, ST],
+    HT <: History[PM, SI, HT]]
+  extends MempoolFilterPerformanceTest[TX]
diff --git a/testkit/src/main/scala/scorex/testkit/BlockchainSanity.scala b/testkit/src/main/scala/scorex/testkit/BlockchainSanity.scala
index fff47a28a..303430276 100644
--- a/testkit/src/main/scala/scorex/testkit/BlockchainSanity.scala
+++ b/testkit/src/main/scala/scorex/testkit/BlockchainSanity.scala
@@ -1,10 +1,10 @@
 package scorex.testkit
 
-import scorex.core.{PersistentNodeViewModifier, TransactionsCarryingPersistentNodeViewModifier}
 import scorex.core.consensus.{History, SyncInfo}
 import scorex.core.transaction.box.Box
 import scorex.core.transaction.box.proposition.Proposition
-import scorex.core.transaction.{BoxTransaction, MemoryPool}
+import scorex.core.transaction.{BoxTransaction, MempoolReader}
+import scorex.core.{PersistentNodeViewModifier, TransactionsCarryingPersistentNodeViewModifier}
 import scorex.mid.state.BoxMinimalState
 import scorex.testkit.generators.AllModifierProducers
 import scorex.testkit.properties._
@@ -21,7 +21,7 @@ PM <: PersistentNodeViewModifier,
 CTM <: PM with TransactionsCarryingPersistentNodeViewModifier[TX],
 SI <: SyncInfo,
 B <: Box[P],
-MPool <: MemoryPool[TX, MPool],
+MPool <: MempoolReader[TX],
 ST <: BoxMinimalState[P, B, TX, PM, ST],
 HT <: History[PM, SI, HT]]
   extends
@@ -31,10 +31,10 @@ HT <: History[PM, SI, HT]]
     with BoxStateApplyChangesTest[P, TX, PM, B, ST]
     with WalletSecretsTest[P, TX, PM]
     with BoxStateRollbackTest[P, TX, PM, CTM, B, ST]
-    with MempoolTransactionsTest[TX, MPool]
-    with MempoolFilterPerformanceTest[TX, MPool]
-    with MempoolRemovalTest[TX, MPool, PM, CTM, HT, SI]
-    with AllModifierProducers[TX, MPool, PM, CTM, ST, SI, HT]
+    with MempoolTransactionsTest[TX]
+    with MempoolFilterPerformanceTest[TX]
+    with MempoolRemovalTest[TX, PM, CTM, HT, SI]
+    with AllModifierProducers[TX, PM, CTM, ST, SI, HT]
     with NodeViewHolderTests[TX, PM, ST, SI, HT, MPool]
-    with NodeViewSynchronizerTests[TX, PM, ST, SI, HT, MPool] {
+    with NodeViewSynchronizerTests[TX, PM, ST, SI, HT] {
 }
diff --git a/testkit/src/main/scala/scorex/testkit/generators/AllModifierProducers.scala b/testkit/src/main/scala/scorex/testkit/generators/AllModifierProducers.scala
index 676ad752a..a65050923 100644
--- a/testkit/src/main/scala/scorex/testkit/generators/AllModifierProducers.scala
+++ b/testkit/src/main/scala/scorex/testkit/generators/AllModifierProducers.scala
@@ -1,20 +1,18 @@
 package scorex.testkit.generators
 
 import scorex.core.consensus.{History, SyncInfo}
-import scorex.core.{PersistentNodeViewModifier, TransactionsCarryingPersistentNodeViewModifier}
-import scorex.core.transaction.{MemoryPool, Transaction}
 import scorex.core.transaction.state.MinimalState
+import scorex.core.transaction.Transaction
+import scorex.core.{PersistentNodeViewModifier, TransactionsCarryingPersistentNodeViewModifier}
 
 
-trait AllModifierProducers[
-TX <: Transaction,
-MPool <: MemoryPool[TX, MPool],
+trait AllModifierProducers[TX <: Transaction,
 PM <: PersistentNodeViewModifier,
 CTM <: PM with TransactionsCarryingPersistentNodeViewModifier[TX],
 ST <: MinimalState[PM, ST],
 SI <: SyncInfo, HT <: History[PM, SI, HT]]
   extends SemanticallyValidModifierProducer[PM, ST]
     with SyntacticallyTargetedModifierProducer[PM, SI, HT]
-    with ArbitraryTransactionsCarryingModifierProducer[TX, MPool, PM, CTM]
+    with ArbitraryTransactionsCarryingModifierProducer[TX, PM, CTM]
     with TotallyValidModifierProducer[PM, ST, SI, HT]
     with SemanticallyValidTransactionsCarryingModifier[TX, PM, CTM, ST]
diff --git a/testkit/src/main/scala/scorex/testkit/generators/ArbitraryTransactionsCarryingModifierProducer.scala b/testkit/src/main/scala/scorex/testkit/generators/ArbitraryTransactionsCarryingModifierProducer.scala
index ef400cc92..dbd9a62e7 100644
--- a/testkit/src/main/scala/scorex/testkit/generators/ArbitraryTransactionsCarryingModifierProducer.scala
+++ b/testkit/src/main/scala/scorex/testkit/generators/ArbitraryTransactionsCarryingModifierProducer.scala
@@ -1,17 +1,14 @@
 package scorex.testkit.generators
 
+import scorex.core.transaction.{MempoolReader, Transaction}
 import scorex.core.{PersistentNodeViewModifier, TransactionsCarryingPersistentNodeViewModifier}
-import scorex.core.transaction.{MemoryPool, Transaction}
-import scorex.core.transaction.box.proposition.Proposition
 
 /**
   * Produces a modifier with transactions, not necessary syntatically or semantically valid
-   */
-trait ArbitraryTransactionsCarryingModifierProducer[
-TX <: Transaction,
-MPool <: MemoryPool[TX, MPool],
-PM <: PersistentNodeViewModifier,
-CTM <: PM with TransactionsCarryingPersistentNodeViewModifier[TX]] {
+  */
+trait ArbitraryTransactionsCarryingModifierProducer[TX <: Transaction,
+    PM <: PersistentNodeViewModifier,
+    CTM <: PM with TransactionsCarryingPersistentNodeViewModifier[TX]] {
 
-def modifierWithTransactions(memoryPoolOpt: Option[MPool], customTransactionsOpt: Option[Seq[TX]]): CTM
+  def modifierWithTransactions(memoryPoolOpt: Option[MempoolReader[TX]], customTransactionsOpt: Option[Seq[TX]]): CTM
 }
diff --git a/testkit/src/main/scala/scorex/testkit/properties/NodeViewHolderTests.scala b/testkit/src/main/scala/scorex/testkit/properties/NodeViewHolderTests.scala
index b9f3e3da1..ba26f117b 100644
--- a/testkit/src/main/scala/scorex/testkit/properties/NodeViewHolderTests.scala
+++ b/testkit/src/main/scala/scorex/testkit/properties/NodeViewHolderTests.scala
@@ -12,9 +12,9 @@ import scorex.core.consensus.{History, SyncInfo}
 import scorex.core.network.NodeViewSynchronizer.ReceivableMessages._
 import scorex.core.transaction.state.MinimalState
 import scorex.core.transaction.wallet.Vault
-import scorex.core.transaction.{MemoryPool, Transaction}
+import scorex.core.transaction.{MempoolReader, Transaction}
 import scorex.testkit.generators._
-import scorex.testkit.utils.AkkaFixture
+import scorex.testkit.utils.BaseActorFixture
 import scorex.util.ScorexLogging
 
 import scala.concurrent.Await
@@ -27,7 +27,7 @@ PM <: PersistentNodeViewModifier,
 ST <: MinimalState[PM, ST],
 SI <: SyncInfo,
 HT <: History[PM, SI, HT],
-MPool <: MemoryPool[TX, MPool]]
+MPool <: MempoolReader[TX]]
   extends PropSpec
     with Matchers
     with PropertyChecks
@@ -40,7 +40,7 @@ MPool <: MemoryPool[TX, MPool]]
 
   def nodeViewHolder(implicit system: ActorSystem): (ActorRef, TestProbe, PM, ST, HT)
 
-  class HolderFixture extends AkkaFixture {
+  class HolderFixture extends BaseActorFixture {
     @SuppressWarnings(Array("org.wartremover.warts.PublicInference"))
     val (node, eventListener, mod, s, h) = nodeViewHolder
   }
@@ -344,4 +344,4 @@ MPool <: MemoryPool[TX, MPool]]
     }
   }
 
-}
\ No newline at end of file
+}
diff --git a/testkit/src/main/scala/scorex/testkit/properties/NodeViewSynchronizerTests.scala b/testkit/src/main/scala/scorex/testkit/properties/NodeViewSynchronizerTests.scala
index ccd328aca..3c2f16142 100644
--- a/testkit/src/main/scala/scorex/testkit/properties/NodeViewSynchronizerTests.scala
+++ b/testkit/src/main/scala/scorex/testkit/properties/NodeViewSynchronizerTests.scala
@@ -1,10 +1,14 @@
 package scorex.testkit.properties
 
 import akka.actor._
-import akka.testkit.TestProbe
+import akka.pattern.ask
+import akka.testkit.{ImplicitSender, TestProbe}
+import akka.util.Timeout
 import org.scalacheck.Gen
 import org.scalatest.prop.PropertyChecks
 import org.scalatest.{Matchers, PropSpec}
+import scorex.core.NodeViewComponent.MempoolComponent
+import scorex.core.NodeViewComponentOperation.GetReader
 import scorex.core.NodeViewHolder.ReceivableMessages.{GetNodeViewChanges, ModifiersFromRemote}
 import scorex.core.PersistentNodeViewModifier
 import scorex.core.consensus.History.{Equal, Nonsense, Older, Younger}
@@ -17,45 +21,34 @@ import scorex.core.network._
 import scorex.core.network.message._
 import scorex.core.serialization.{BytesSerializable, Serializer}
 import scorex.core.transaction.state.MinimalState
-import scorex.core.transaction.{MemoryPool, Transaction}
+import scorex.core.transaction.{MempoolReader, Transaction}
 import scorex.testkit.generators.{SyntacticallyTargetedModifierProducer, TotallyValidModifierProducer}
-import scorex.testkit.utils.AkkaFixture
+import scorex.testkit.utils.BaseActorFixture
 import scorex.util.ScorexLogging
 
-import scala.concurrent.Await
+import scala.concurrent.{Await, ExecutionContext}
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
 import scala.language.postfixOps
-import scala.util.Failure
+import scala.util.{Failure, Success}
 
 @SuppressWarnings(Array("org.wartremover.warts.IsInstanceOf"))
-trait NodeViewSynchronizerTests[
-TX <: Transaction,
-PM <: PersistentNodeViewModifier,
-ST <: MinimalState[PM, ST],
-SI <: SyncInfo,
-HT <: History[PM, SI, HT],
-MP <: MemoryPool[TX, MP]
-] extends PropSpec
+trait NodeViewSynchronizerTests[TX <: Transaction, PM <: PersistentNodeViewModifier, State <: MinimalState[PM, State],
+                                SI <: SyncInfo, HT <: History[PM, SI, HT]]
+  extends PropSpec
   with Matchers
   with PropertyChecks
   with ScorexLogging
   with SyntacticallyTargetedModifierProducer[PM, SI, HT]
-  with TotallyValidModifierProducer[PM, ST, SI, HT] {
+  with TotallyValidModifierProducer[PM, State, SI, HT] {
 
   val historyGen: Gen[HT]
-  val memPool: MP
 
-  def nodeViewSynchronizer(implicit system: ActorSystem): (ActorRef, SI, PM, TX, ConnectedPeer, TestProbe, TestProbe, TestProbe, TestProbe)
-
-  class SynchronizerFixture extends AkkaFixture {
-    @SuppressWarnings(Array("org.wartremover.warts.PublicInference"))
-    val (node, syncInfo, mod, tx, peer, pchProbe, ncProbe, vhProbe, eventListener) = nodeViewSynchronizer
-  }
+  def createFixture(): SynchronizerFixture[TX, PM, SI]
 
   // ToDo: factor this out of here and NVHTests?
-  private def withFixture(testCode: SynchronizerFixture => Any): Unit = {
-    val fixture = new SynchronizerFixture
+  private def withFixture(testCode: SynchronizerFixture[TX, PM, SI] => Any): Unit = {
+    val fixture = createFixture()
     try {
       testCode(fixture)
     }
@@ -64,6 +57,8 @@ MP <: MemoryPool[TX, MP]
     }
   }
 
+  implicit val timeout: Timeout = Timeout(10.seconds)
+
   property("NodeViewSynchronizer: SuccessfulTransaction") {
     withFixture { ctx =>
       import ctx._
@@ -203,12 +198,14 @@ MP <: MemoryPool[TX, MP]
       val h = historyGen.sample.get
       val mod = syntacticallyValidModifier(h)
       val (newH, _) = h.append(mod).get
-      val m = memPool
       val spec = new RequestModifierSpec(3)
       val modifiers = Seq(mod.id)
       node ! ChangedHistory(newH)
-      node ! ChangedMempool(m)
       node ! DataFromPeer(spec, (mod.modifierTypeId, modifiers), peer)
+      (memoryPool ? GetReader(MempoolComponent)).mapTo[MempoolReader[TX]].onComplete {
+        case Success(reader) => node ! ChangedMempool(reader)
+        case Failure(e) => log.error(s"Cannot get memory pool reader ${e.getMessage}", e)
+      }
 
       pchProbe.fishForMessage(5 seconds) {
         case _: Message[_] => true
@@ -268,3 +265,17 @@ MP <: MemoryPool[TX, MP]
   }
 
 }
+
+class SynchronizerFixture[TX <: Transaction, PM <: PersistentNodeViewModifier, SI <: SyncInfo](
+    system: ActorSystem,
+    val node: ActorRef,
+    val memoryPool: ActorRef,
+    val syncInfo: SI,
+    val mod: PM,
+    val tx: TX,
+    val peer: ConnectedPeer,
+    val pchProbe: TestProbe,
+    val ncProbe: TestProbe,
+    val vhProbe: TestProbe,
+    val eventListener: TestProbe
+) extends BaseActorFixture(system)
diff --git a/testkit/src/main/scala/scorex/testkit/properties/mempool/MemoryPoolTest.scala b/testkit/src/main/scala/scorex/testkit/properties/mempool/MemoryPoolTest.scala
index 0438c61ed..102936a02 100644
--- a/testkit/src/main/scala/scorex/testkit/properties/mempool/MemoryPoolTest.scala
+++ b/testkit/src/main/scala/scorex/testkit/properties/mempool/MemoryPoolTest.scala
@@ -1,12 +1,42 @@
 package scorex.testkit.properties.mempool
 
+import akka.actor.{ActorRef, ActorSystem}
 import org.scalacheck.Gen
-import scorex.core.transaction.box.proposition.Proposition
-import scorex.core.transaction.{MemoryPool, Transaction}
+import org.scalatest.{BeforeAndAfterAll, Suite}
+import scorex.core.transaction.Transaction
 
 
-trait MemoryPoolTest[TX <: Transaction, MPool <: MemoryPool[TX, MPool]] {
-  val memPool: MPool
-  val memPoolGenerator: Gen[MPool]
+trait MemoryPoolTest[TX <: Transaction] extends BeforeAndAfterAll { this: Suite =>
+
+  type MPool = MempoolFixture[TX]
+
+  protected def createMempoolActor(system: ActorSystem): ActorRef
+
   val transactionGenerator: Gen[TX]
+
+  @volatile private var defaultMempoolAccessed: Boolean = false
+
+  lazy val defaultMempool: MPool = {
+    defaultMempoolAccessed = true
+    new MempoolFixture(createMempoolActor)
+  }
+
+  override protected def afterAll(): Unit = {
+    if (defaultMempoolAccessed) defaultMempool.close()
+    super.afterAll()
+  }
+
+  /** Mempool generator that clean mempool on every generation and reuse it
+    */
+  def mempoolGenerator: Gen[MPool] = defaultMempool.mempoolGenerator
+
+  def withNewMempool(block: MPool => Any): Unit = {
+    val fixture = new MempoolFixture[TX](createMempoolActor)
+    try {
+      block(fixture)
+    } finally {
+      fixture.close()
+    }
+  }
 }
+
diff --git a/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolFilterPerformanceTest.scala b/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolFilterPerformanceTest.scala
index 0d20b1779..5b3393c0e 100644
--- a/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolFilterPerformanceTest.scala
+++ b/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolFilterPerformanceTest.scala
@@ -1,20 +1,18 @@
 package scorex.testkit.properties.mempool
 
 import java.security.MessageDigest
+
 import org.scalatest.prop.{GeneratorDrivenPropertyChecks, PropertyChecks}
 import org.scalatest.{Matchers, PropSpec}
-import scorex.core.transaction.box.proposition.Proposition
-import scorex.core.transaction.{MemoryPool, Transaction}
+import scorex.core.transaction.Transaction
 import scorex.core.utils._
 
-trait MempoolFilterPerformanceTest[TX <: Transaction, MPool <: MemoryPool[TX, MPool]]
+trait MempoolFilterPerformanceTest[TX <: Transaction]
   extends PropSpec
     with GeneratorDrivenPropertyChecks
     with Matchers
     with PropertyChecks
-    with MemoryPoolTest[TX, MPool] {
-
-  var initializedMempool: Option[MPool] = None
+    with MemoryPoolTest[TX] {
 
   val thresholdInHashes = 500000
 
@@ -30,32 +28,28 @@ trait MempoolFilterPerformanceTest[TX <: Transaction, MPool <: MemoryPool[TX, MP
     (t - t0) / 1000.0
   }
 
+  val m = defaultMempool
+
   property("Mempool should be able to store a lot of transactions") {
-    var m: MPool = memPool
     (0 until 1000) foreach { _ =>
       forAll(transactionGenerator) { tx: TX =>
-        m = m.put(tx).get
+        m.put(tx)
       }
     }
     m.size should be > 1000
-    initializedMempool = Some(m)
   }
 
   property("Mempool filter of non-existing transaction should be fast") {
-    @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-    val m = initializedMempool.get
     forAll(transactionGenerator) { tx: TX =>
-      val (time, _) = profile(m.filter(Seq(tx)))
+      val (time, _) = profile(m.remove(tx))
       assert(time < thresholdSecs)
     }
   }
 
   property("Mempool filter of existing transaction should be fast") {
-    @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-    var m = initializedMempool.get
     forAll(transactionGenerator) { tx: TX =>
-      m = m.put(tx).get
-      val (time, _) = profile(m.filter(Seq(tx)))
+      m.put(tx).get
+      val (time, _) = profile(m.remove(tx))
       assert(time < thresholdSecs)
     }
   }
diff --git a/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolFixture.scala b/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolFixture.scala
new file mode 100644
index 000000000..66bebf155
--- /dev/null
+++ b/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolFixture.scala
@@ -0,0 +1,89 @@
+package scorex.testkit.properties.mempool
+
+import akka.actor.{ActorRef, ActorSystem}
+import akka.pattern.ask
+import akka.util.Timeout
+import org.scalacheck.Gen
+import scorex.core.NodeViewComponent.MempoolComponent
+import scorex.core.NodeViewComponentOperation.GetReader
+import scorex.core.transaction.MempoolOperation._
+import scorex.core.transaction.{MempoolReader, ReferenceMempool, Transaction}
+import scorex.testkit.utils.BaseActorFixture
+import scorex.util.{ModifierId, ScorexLogging}
+
+import scala.concurrent.duration._
+import scala.concurrent.{Await, Future}
+import scala.concurrent.blocking
+import scala.util.Try
+
+class MempoolFixture[TX <: Transaction](mempoolActorGen: ActorSystem => ActorRef)
+  extends BaseActorFixture with ReferenceMempool[TX, MempoolFixture[TX]] with ScorexLogging {
+
+  type M = MempoolFixture[TX]
+
+  val mempoolActor: ActorRef = mempoolActorGen(system)
+
+  /** Mempool generator that clean mempool on every generation and reuse it
+    */
+  val mempoolGenerator: Gen[M] = Gen.const(this).map({r => clear(); r})
+
+  implicit protected val timeout: Timeout = Timeout(10.seconds)
+
+  def await[T](future: Future[T]): T = Await.result(future, timeout.duration)
+
+  def put(tx: TX): Try[M] = {
+    await((mempoolActor ? Put(tx)).mapTo[PutResponse[TX]]).result.map(_ => this)
+  }
+
+  def putWithoutCheck(tx: TX): M = {
+    mempoolActor ! PutWithoutCheck(tx)
+    this
+  }
+
+  def remove(tx: TX): M = {
+    mempoolActor ! Remove(tx)
+    this
+  }
+
+  def filterBy(condition: TX => Boolean): M = {
+    mempoolActor ! FilterBy(condition)
+    this
+  }
+
+  def clear(): Unit = {
+    mempoolActor ! FilterBy({ _: TX => false })
+    blocking(Thread.sleep(10))
+  }
+
+  /** Get the reader for the memory pool
+    */
+  override def getReader: MempoolReader[TX] = {
+    await((mempoolActor ? GetReader(MempoolComponent)).mapTo[MempoolReader[TX]])
+  }
+
+  override def modifierById(modifierId: ModifierId): Option[TX] = {
+    getReader.modifierById(modifierId)
+  }
+
+  override def contains(id: ModifierId): Boolean = {
+    getReader.contains(id)
+  }
+
+  override def notIn(ids: Seq[ModifierId]): Seq[ModifierId] = {
+    val reader = getReader
+    ids.filter(id => !reader.contains(id))
+  }
+
+  def getAll(ids: Seq[ModifierId]): Seq[TX] = {
+    getReader.getAll(ids)
+  }
+
+  def size: Int = {
+    getReader.size
+  }
+
+  def take(limit: Int): Iterable[TX] = {
+    getReader.take(limit)
+  }
+
+}
diff --git a/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolRemovalTest.scala b/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolRemovalTest.scala
index 87300c829..2d55b58eb 100644
--- a/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolRemovalTest.scala
+++ b/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolRemovalTest.scala
@@ -5,41 +5,37 @@ import org.scalatest.prop.{GeneratorDrivenPropertyChecks, PropertyChecks}
 import org.scalatest.{Matchers, PropSpec}
 import scorex.core.{PersistentNodeViewModifier, TransactionsCarryingPersistentNodeViewModifier}
 import scorex.core.consensus.{History, SyncInfo}
-import scorex.core.transaction.{MemoryPool, Transaction}
+import scorex.core.transaction.Transaction
 import scorex.testkit.TestkitHelpers
 import scorex.testkit.generators.ArbitraryTransactionsCarryingModifierProducer
 import scorex.util.ScorexLogging
 
-trait MempoolRemovalTest[
-TX <: Transaction,
-MPool <: MemoryPool[TX, MPool],
-PM <: PersistentNodeViewModifier,
-CTM <: PM with TransactionsCarryingPersistentNodeViewModifier[TX],
-HT <: History[PM, SI, HT],
-SI <: SyncInfo] extends PropSpec
+trait MempoolRemovalTest[TX <: Transaction,
+    PM <: PersistentNodeViewModifier,
+    CTM <: PM with TransactionsCarryingPersistentNodeViewModifier[TX],
+    HT <: History[PM, SI, HT],
+    SI <: SyncInfo]
+  extends PropSpec
   with GeneratorDrivenPropertyChecks
   with Matchers
   with PropertyChecks
   with ScorexLogging
   with TestkitHelpers
-  with MemoryPoolTest[TX, MPool]
-  with ArbitraryTransactionsCarryingModifierProducer[TX, MPool, PM, CTM] {
+  with MemoryPoolTest[TX]
+  with ArbitraryTransactionsCarryingModifierProducer[TX, PM, CTM] {
 
   val historyGen: Gen[HT]
 
   //todo: this test doesn't check anything. It should be reworked as a test for node view holder
-  property("Transactions once added to block should be removed from Mempool") {
+  ignore("Transactions once added to block should be removed from Mempool") {
     val min = 1
     val max = 10
     forAll(Gen.choose(min, max)) { noOfTransactionsFromMempool: Int =>
-      var m: MPool = memPool
-      @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-      var h: HT = historyGen.sample.get
       forAll(transactionGenerator) { tx: TX =>
-        m = m.put(tx).get
+        //mempool.put(tx)
       }
       // var prevMempoolSize = m.size
-      val b = modifierWithTransactions(Some(m), None)
+      //val b = modifierWithTransactions(Some(mempool.getReader), None)
       //todo: fix    (m.size + b.transactions.get.size) shouldEqual prevMempoolSize
     }
   }
diff --git a/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolTransactionsTest.scala b/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolTransactionsTest.scala
index 0c47156f6..9a32ece98 100644
--- a/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolTransactionsTest.scala
+++ b/testkit/src/main/scala/scorex/testkit/properties/mempool/MempoolTransactionsTest.scala
@@ -3,157 +3,141 @@ package scorex.testkit.properties.mempool
 import org.scalacheck.Gen
 import org.scalatest.prop.{GeneratorDrivenPropertyChecks, PropertyChecks}
 import org.scalatest.{Matchers, PropSpec}
-import scorex.core.transaction.{MemoryPool, Transaction}
+import scorex.core.transaction.Transaction
 
 @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
-trait MempoolTransactionsTest[TX <: Transaction, MPool <: MemoryPool[TX, MPool]]
+trait MempoolTransactionsTest[TX <: Transaction]
   extends PropSpec
     with GeneratorDrivenPropertyChecks
     with Matchers
     with PropertyChecks
-    with MemoryPoolTest[TX, MPool] {
-
+    with MemoryPoolTest[TX] {
+  
   val transactionSeqGenerator: Gen[Seq[TX]] = Gen.nonEmptyContainerOf[Seq, TX](transactionGenerator)
 
   property("Size of mempool should increase when adding a non-present transaction") {
-    forAll(memPoolGenerator, transactionGenerator) { (mp: MPool, tx: TX) =>
-      val m: MPool = mp.put(tx).get
+    forAll(mempoolGenerator, transactionGenerator) { (m: MPool, tx: TX) =>
+      m.put(tx)
       m.size shouldEqual 1
     }
   }
 
   property("Size of mempool should not increase when adding a present transaction") {
-    forAll(memPoolGenerator, transactionGenerator) { (mp: MPool, tx: TX) =>
-      val m: MPool = mp.put(tx).get
-      val m2: MPool = m.put(tx).get
-      m2.size shouldEqual 1
+    forAll(mempoolGenerator, transactionGenerator) { (m: MPool, tx: TX) =>
+      m.put(tx)
+      m.put(tx)
+      m.size shouldEqual 1
     }
   }
 
   property("Size of mempool should increase when adding a collection of non-present transactions " +
     "without duplicates (with check)") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.put(txs).get
+    forAll(mempoolGenerator, transactionSeqGenerator) { (m: MPool, txs: Seq[TX]) =>
+      txs.foreach(m.put)
       m.size shouldEqual txs.size
     }
   }
 
   property("Size of mempool should increase for a number of unique non-present transactions " +
     "when adding a collection of non-present txs with duplicates (with check)") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.put(txs ++ txs).get
+    forAll(mempoolGenerator, transactionSeqGenerator) { (m: MPool, txs: Seq[TX]) =>
+      (txs ++ txs).foreach(m.put)
       m.size shouldEqual txs.size
     }
   }
 
-  property("Size of mempool should not increase when adding a collection of present transactions (with check)") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.put(txs).get
-      val m2: MPool = m.put(txs).get
-      m2.size shouldEqual txs.size
-    }
-  }
-
   property("Size of mempool should increase when adding a collection of non-present transactions " +
     "without duplicates (without check)") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.putWithoutCheck(txs)
-      m.size shouldEqual txs.size
+    forAll(mempoolGenerator, transactionSeqGenerator) { (m: MPool, txs: Seq[TX]) =>
+      txs.foreach(m.putWithoutCheck)
+      m.size
     }
   }
 
   property("Size of mempool should increase for a number of unique non-present transactions " +
     "when adding a collection of non-present transactions with duplicates (without check)") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.putWithoutCheck(txs ++ txs)
+    forAll(mempoolGenerator, transactionSeqGenerator) { (m: MPool, txs: Seq[TX]) =>
+      (txs ++ txs).foreach(m.putWithoutCheck)
       m.size shouldEqual txs.size
     }
   }
 
-  property("Size of mempool should not increase when adding a collection of present transactions (without check)") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.putWithoutCheck(txs)
-      val m2: MPool = m.putWithoutCheck(txs)
-      m2.size shouldEqual txs.size
-    }
-  }
-
   property("Size of mempool should decrease when removing a present transaction") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.put(txs).get
-      val m2: MPool = m.remove(txs.headOption.get)
-      m2.size shouldBe txs.size - 1
+    forAll(mempoolGenerator, transactionSeqGenerator) { (m: MPool, txs: Seq[TX]) =>
+      txs.foreach(m.put)
+      m.remove(txs.headOption.get)
+      m.size shouldBe txs.size - 1
     }
   }
 
   property("Size of mempool should not decrease when removing a non-present transaction") {
-    forAll(memPoolGenerator, transactionSeqGenerator, transactionGenerator) { (mp: MPool, txs: Seq[TX], tx: TX) =>
-      val m: MPool = mp.put(txs).get
-      val m2: MPool = m.remove(tx)
-      m2.size shouldBe txs.size
+    forAll(mempoolGenerator, transactionSeqGenerator, transactionGenerator) { (m: MPool, txs: Seq[TX], tx: TX) =>
+      txs.foreach(m.put)
+      m.remove(tx)
+      m.size shouldBe txs.size
     }
   }
 
   property("Mempool transactions should be filtered successfully") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.put(txs).get
-      val m2: MPool = m.filter(tx => tx equals txs.headOption.get)
-      m2.size shouldBe 1
+    forAll(mempoolGenerator, transactionSeqGenerator) { (m: MPool, txs: Seq[TX]) =>
+      txs.foreach(m.put)
+      m.filterBy(tx => tx equals txs.headOption.get)
+      m.size shouldBe 1
     }
   }
 
   property("Present transactions should be available by id") {
-    forAll(memPoolGenerator, transactionGenerator) { (mp: MPool, tx: TX) =>
-      val m: MPool = mp.put(tx).get
-      m.getById(tx.id).isDefined shouldBe true
+    forAll(mempoolGenerator, transactionGenerator) { (m: MPool, tx: TX) =>
+      m.put(tx)
+      m.modifierById(tx.id).isDefined shouldBe true
     }
   }
 
   property("Non-present transactions should not be available by id") {
-    forAll(memPoolGenerator, transactionSeqGenerator, transactionGenerator) { (mp: MPool, txs: Seq[TX], tx: TX) =>
-      val m: MPool = mp.put(txs).get
-      m.getById(tx.id).isDefined shouldBe false
+    forAll(mempoolGenerator, transactionSeqGenerator, transactionGenerator) { (m: MPool, txs: Seq[TX], tx: TX) =>
+      txs.foreach(m.put)
+      m.modifierById(tx.id).isDefined shouldBe false
     }
   }
 
   property("Mempool should contain present transactions") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.put(txs).get
+    forAll(mempoolGenerator, transactionSeqGenerator) { (m: MPool, txs: Seq[TX]) =>
+      txs.foreach(m.put)
       m.contains(txs.headOption.get.id) shouldBe true
     }
   }
 
   property("Mempool should not contain non-present transactions") {
-    forAll(memPoolGenerator, transactionSeqGenerator, transactionGenerator) { (mp: MPool, txs: Seq[TX], tx: TX) =>
-      val m: MPool = mp.put(txs).get
+    forAll(mempoolGenerator, transactionSeqGenerator, transactionGenerator) { (m: MPool, txs: Seq[TX], tx: TX) =>
+      txs.foreach(m.put)
       m.contains(tx.id) shouldBe false
     }
   }
 
   property("Present transactions should be obtained by their ids") {
-    forAll(memPoolGenerator, transactionSeqGenerator, transactionGenerator) { (mp: MPool, txs: Seq[TX], tx: TX) =>
-      val m: MPool = mp.put(txs :+ tx).get
+    forAll(mempoolGenerator, transactionSeqGenerator, transactionGenerator) { (m: MPool, txs: Seq[TX], tx: TX) =>
+      (txs :+ tx).foreach(m.put)
       m.getAll(txs.map(_.id)) sameElements txs
     }
   }
 
   property("Non-present transactions should not be obtained by their ids") {
-    forAll(memPoolGenerator, transactionSeqGenerator, transactionGenerator) { (mp: MPool, txs: Seq[TX], tx: TX) =>
-      val m: MPool = mp.put(tx).get
+    forAll(mempoolGenerator, transactionSeqGenerator, transactionGenerator) { (m: MPool, txs: Seq[TX], tx: TX) =>
+      m.put(tx)
       m.getAll(txs.map(_.id)).size shouldBe 0
     }
   }
 
   property("Required number of transactions should be taken from mempool") {
-    forAll(memPoolGenerator, transactionSeqGenerator, transactionGenerator) { (mp: MPool, txs: Seq[TX], tx: TX) =>
-      val m: MPool = mp.put(txs :+ tx).get
+    forAll(mempoolGenerator, transactionSeqGenerator, transactionGenerator) { (m: MPool, txs: Seq[TX], tx: TX) =>
+      (txs :+ tx).foreach(m.put)
       m.take(txs.size).size shouldBe txs.size
     }
   }
 
   property("Maximum number of transactions that can be taken should equals mempool size") {
-    forAll(memPoolGenerator, transactionSeqGenerator) { (mp: MPool, txs: Seq[TX]) =>
-      val m: MPool = mp.put(txs).get
+    forAll(mempoolGenerator, transactionSeqGenerator) { (m: MPool, txs: Seq[TX]) =>
+      txs.foreach(m.put)
       m.take(txs.size + 1).size shouldBe m.size
     }
   }
diff --git a/testkit/src/main/scala/scorex/testkit/utils/AkkaFixture.scala b/testkit/src/main/scala/scorex/testkit/utils/BaseActorFixture.scala
similarity index 55%
rename from testkit/src/main/scala/scorex/testkit/utils/AkkaFixture.scala
rename to testkit/src/main/scala/scorex/testkit/utils/BaseActorFixture.scala
index c3aa3b978..ce7294348 100644
--- a/testkit/src/main/scala/scorex/testkit/utils/AkkaFixture.scala
+++ b/testkit/src/main/scala/scorex/testkit/utils/BaseActorFixture.scala
@@ -10,6 +10,11 @@ object SysId {
   def incrementAndGet(): Int = i.incrementAndGet()
 }
 
-class AkkaFixture
-  extends TestKit(ActorSystem("WithIsoFix-%d".format(SysId.incrementAndGet())))
-    with ImplicitSender
+class BaseActorFixture(system: ActorSystem = ActorSystem("WithIsoFix-%d".format(SysId.incrementAndGet())))
+  extends TestKit(system)
+    with ImplicitSender {
+
+  def close(): Unit = {
+    shutdown(system)
+  }
+}