dBFT 2.0 (neo-project#547)

* Add commit phase to consensus algorithm (neo-project#534)

* Add commit phase to consensus algorithm

* fix tests

* Prevent repeated sending of `Commit` messages

* RPC call gettransactionheight (neo-project#541)

* getrawtransactionheight

Nowadays two calls are need to get a transaction height, `getrawtransaction` with `verbose` and then use the `blockhash`.
Other option is to use `confirmations`, but it can be misleading.

* Minnor fix

* Shargon's tip

* modified

* Allow to use the wallet inside a RPC plugin (neo-project#536)

* Clean code

* Clean code

* Minor fix on mempoolVerified

* Add MemoryPool Unit tests. Fix bug on initital start of Persisting the Genesis block.

* Prevent `ConsensusService` from receiving messages before starting (neo-project#573)

* Prevent `ConsensusService` from receiving messages before starting

* fixed tests - calling OnStart now

* Consensus recovery log (neo-project#572)

* Pass store to `ConsensusService`

* Implement `ISerializable` in `ConsensusContext`

* Start from recovery log

* Fix unit tests due to constructor taking the store.

* Add unit tests for serializing and deserializing the consensus context.

* Combine `ConsensusContext.ChangeView()` and `ConsensusContext.Reset()`

* Add `PreparationHash` field to `PrepareResponse` to prevent replay attacks from malicious primary (neo-project#576)

* Fixed a problem where `PrepareResponse.PreparationHash` was not assigned.

* Load context from store only when height matches

* Recover nodes requesting ChangeView when possible (neo-project#579)

* Fixes bug in `OnPrepareRequestReceived()`

* Send `RecoveryMessage` only when `message.NewViewNumber <= context.ViewNumber`

* Fix and optimize view changing (#590)

* Allow to ignore the recovery logs

* Add `isRecovering` (neo-project#594)

* Fix accepting own prepare request (neo-project#596)

* Pick some changes from neo-project#575.

* Fixes `Prefixes`

* Restore transactions from saved consensus context (neo-project#598)

* Refactoring

* AggressiveInlining (neo-project#606)

* Reset Block reference when consensus context is initialized after block persist. (neo-project#608)

* Change `ConsensusPayload` for compatibility (neo-project#609)

neo.UnitTests/TestBlockchain.cs

@@ -0,0 +1,65 @@
+using Moq;
+using Neo.Cryptography.ECC;
+using Neo.IO.Wrappers;
+using Neo.Ledger;
+using Neo.Persistence;
+using System;
+
+namespace Neo.UnitTests
+{
+    public static class TestBlockchain
+    {
+        private static NeoSystem TheNeoSystem;
+
+        public static NeoSystem InitializeMockNeoSystem()
+        {
+            if (TheNeoSystem == null)
+            {
+                var mockSnapshot = new Mock<Snapshot>();
+                mockSnapshot.SetupGet(p => p.Blocks).Returns(new TestDataCache<UInt256, BlockState>());
+                mockSnapshot.SetupGet(p => p.Transactions).Returns(new TestDataCache<UInt256, TransactionState>());
+                mockSnapshot.SetupGet(p => p.Accounts).Returns(new TestDataCache<UInt160, AccountState>());
+                mockSnapshot.SetupGet(p => p.UnspentCoins).Returns(new TestDataCache<UInt256, UnspentCoinState>());
+                mockSnapshot.SetupGet(p => p.SpentCoins).Returns(new TestDataCache<UInt256, SpentCoinState>());
+                mockSnapshot.SetupGet(p => p.Validators).Returns(new TestDataCache<ECPoint, ValidatorState>());
+                mockSnapshot.SetupGet(p => p.Assets).Returns(new TestDataCache<UInt256, AssetState>());
+                mockSnapshot.SetupGet(p => p.Contracts).Returns(new TestDataCache<UInt160, ContractState>());
+                mockSnapshot.SetupGet(p => p.Storages).Returns(new TestDataCache<StorageKey, StorageItem>());
+                mockSnapshot.SetupGet(p => p.HeaderHashList)
+                    .Returns(new TestDataCache<UInt32Wrapper, HeaderHashList>());
+                mockSnapshot.SetupGet(p => p.ValidatorsCount).Returns(new TestMetaDataCache<ValidatorsCountState>());
+                mockSnapshot.SetupGet(p => p.BlockHashIndex).Returns(new TestMetaDataCache<HashIndexState>());
+                mockSnapshot.SetupGet(p => p.HeaderHashIndex).Returns(new TestMetaDataCache<HashIndexState>());
+
+                var mockStore = new Mock<Store>();
+
+                var defaultTx = TestUtils.CreateRandomHashInvocationMockTransaction().Object;
+                mockStore.Setup(p => p.GetBlocks()).Returns(new TestDataCache<UInt256, BlockState>());
+                mockStore.Setup(p => p.GetTransactions()).Returns(new TestDataCache<UInt256, TransactionState>(
+                    new TransactionState
+                    {
+                        BlockIndex = 1,
+                        Transaction = defaultTx
+                    }));
+
+                mockStore.Setup(p => p.GetAccounts()).Returns(new TestDataCache<UInt160, AccountState>());
+                mockStore.Setup(p => p.GetUnspentCoins()).Returns(new TestDataCache<UInt256, UnspentCoinState>());
+                mockStore.Setup(p => p.GetSpentCoins()).Returns(new TestDataCache<UInt256, SpentCoinState>());
+                mockStore.Setup(p => p.GetValidators()).Returns(new TestDataCache<ECPoint, ValidatorState>());
+                mockStore.Setup(p => p.GetAssets()).Returns(new TestDataCache<UInt256, AssetState>());
+                mockStore.Setup(p => p.GetContracts()).Returns(new TestDataCache<UInt160, ContractState>());
+                mockStore.Setup(p => p.GetStorages()).Returns(new TestDataCache<StorageKey, StorageItem>());
+                mockStore.Setup(p => p.GetHeaderHashList()).Returns(new TestDataCache<UInt32Wrapper, HeaderHashList>());
+                mockStore.Setup(p => p.GetValidatorsCount()).Returns(new TestMetaDataCache<ValidatorsCountState>());
+                mockStore.Setup(p => p.GetBlockHashIndex()).Returns(new TestMetaDataCache<HashIndexState>());
+                mockStore.Setup(p => p.GetHeaderHashIndex()).Returns(new TestMetaDataCache<HashIndexState>());
+                mockStore.Setup(p => p.GetSnapshot()).Returns(mockSnapshot.Object);
+
+                Console.WriteLine("initialize NeoSystem");
+                TheNeoSystem = new NeoSystem(mockStore.Object); // new Mock<NeoSystem>(mockStore.Object);
+            }
+
+            return TheNeoSystem;
+        }
+    }
+}

neo.UnitTests/TestUtils.cs

@@ -1,14 +1,21 @@
-using Neo.Cryptography.ECC;
+using Moq;
+using Neo.Cryptography.ECC;
+using Neo.IO;
 using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
 using Neo.VM;
 using System;
+using System.Collections.Generic;
+using System.IO;
 
 namespace Neo.UnitTests
 {
     public static class TestUtils
     {
+        public static readonly Random TestRandom = new Random(1337); // use fixed seed for guaranteed determinism
+
         public static byte[] GetByteArray(int length, byte firstByte)
-        {            
+        {
             byte[] array = new byte[length];
             array[0] = firstByte;
             for (int i = 1; i < length; i++)
@@ -95,5 +102,50 @@ private static void setupBlockBaseWithValues(BlockBase bb, UInt256 val256, out U
             };
             bb.Witness = scriptVal;
         }
-    }    
+
+        public static Mock<InvocationTransaction> CreateRandomHashInvocationMockTransaction()
+        {
+            var mockTx = new Mock<InvocationTransaction>
+            {
+                CallBase = true
+            };
+            mockTx.Setup(p => p.Verify(It.IsAny<Snapshot>(), It.IsAny<IEnumerable<Transaction>>())).Returns(true);
+            var tx = mockTx.Object;
+            var randomBytes = new byte[16];
+            TestRandom.NextBytes(randomBytes);
+            tx.Script = randomBytes;
+            tx.Attributes = new TransactionAttribute[0];
+            tx.Inputs = new CoinReference[0];
+            tx.Outputs = new TransactionOutput[0];
+            tx.Witnesses = new Witness[0];
+
+            return mockTx;
+        }
+
+        public static Mock<MinerTransaction> CreateRandomMockMinerTransaction()
+        {
+            var mockTx = new Mock<MinerTransaction>
+            {
+                CallBase = true
+            };
+            var tx = mockTx.Object;
+            tx.Attributes = new TransactionAttribute[0];
+            tx.Inputs = new CoinReference[0];
+            tx.Outputs = new TransactionOutput[0];
+            tx.Witnesses = new Witness[0];
+            tx.Nonce = (uint)TestRandom.Next();
+            return mockTx;
+        }
+
+        public static T CopyMsgBySerialization<T>(T serializableObj, T newObj) where T : ISerializable
+        {
+            using (MemoryStream ms = new MemoryStream(serializableObj.ToArray(), false))
+            using (BinaryReader reader = new BinaryReader(ms))
+            {
+                newObj.Deserialize(reader);
+            }
+
+            return newObj;
+        }
+    }
 }