[neox] Merge neo-project/neox to neo-project/master

src/neo/Ledger/Blockchain.State.cs

@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using Akka.Actor;
+using Neo.Cryptography.MPT;
+using Neo.Network.P2P;
+using Neo.Network.P2P.Payloads;
+using Neo.Persistence;
+
+namespace Neo.Ledger
+{
+    public sealed partial class Blockchain : UntypedActor
+    {
+        public StateRoot LatestValidatorsStateRoot
+        {
+            get
+            {
+                var state_root = currentSnapshot.ValidatorsStateRoot.Get();
+                return state_root.RootHash is null ? null : state_root;
+            }
+        }
+        public long StateHeight => LatestValidatorsStateRoot is null ? -1 : (long)LatestValidatorsStateRoot.Index;
+
+        private readonly int MaxStateRootCacheCount = 100;
+        private Dictionary<uint, StateRoot> state_root_cache = new Dictionary<uint, StateRoot>();
+
+        public UInt256 GetLocalStateRoot(uint index)
+        {
+            return currentSnapshot.LocalStateRoot.TryGet(index)?.Hash;
+        }
+
+        private VerifyResult OnNewStateRoot(StateRoot root)
+        {
+            if (LatestValidatorsStateRoot != null && root.Index <= LatestValidatorsStateRoot.Index) return VerifyResult.AlreadyExists;
+            if (Height + MaxStateRootCacheCount < root.Index) return VerifyResult.Invalid;
+            if (Height < root.Index && root.Index <= Height + MaxStateRootCacheCount)
+            {
+                if (!state_root_cache.TryAdd(root.Index, root)) return VerifyResult.AlreadyExists;
+                return VerifyResult.Succeed;
+            }
+            var result = PersistCnStateRoot(root);
+            if (result == VerifyResult.Succeed && Height < root.Index + 2)
+                system.LocalNode.Tell(new LocalNode.SendDirectly { Inventory = root });
+            return result;
+        }
+
+        private VerifyResult PersistCnStateRoot(StateRoot root)
+        {
+            if (!root.Verify(currentSnapshot)) return VerifyResult.Invalid;
+            if (currentSnapshot.LocalStateRoot.TryGet(root.Index)?.Hash == root.RootHash)
+            {
+                using (SnapshotView snapshot = GetSnapshot())
+                {
+                    var confirmedRoot = snapshot.ValidatorsStateRoot.GetAndChange();
+                    confirmedRoot.Version = root.Version;
+                    confirmedRoot.Index = root.Index;
+                    confirmedRoot.RootHash = root.RootHash;
+                    confirmedRoot.Witness = root.Witness;
+                    snapshot.Commit();
+                }
+                UpdateCurrentSnapshot();
+                return VerifyResult.Succeed;
+            }
+            if (StateRoot.CurrentVersion < root.Version && Height < root.Index + 2)
+                system.LocalNode.Tell(new LocalNode.SendDirectly { Inventory = root });
+            return VerifyResult.Invalid;
+        }
+
+        private void CheckStateRootCache()
+        {
+            var index = (long)Height - 1;
+            if (0 <= index && state_root_cache.TryGetValue((uint)index, out StateRoot root))
+            {
+                state_root_cache.Remove((uint)index);
+                OnNewStateRoot(root);
+            }
+        }
+    }
+}

src/neo/Ledger/Blockchain.cs

@@ -487,6 +487,7 @@ private void Persist(Block block)
                 }
                 foreach (IPersistencePlugin plugin in Plugin.PersistencePlugins)
                     plugin.OnPersist(snapshot, all_application_executed);
+                snapshot.UpdateLocalStateRoot();
                 snapshot.Commit();
                 List<Exception> commitExceptions = null;
                 foreach (IPersistencePlugin plugin in Plugin.PersistencePlugins)
@@ -509,6 +510,7 @@ private void Persist(Block block)
                 if (commitExceptions != null) throw new AggregateException(commitExceptions);
             }
             UpdateCurrentSnapshot();
+            CheckStateRootCache();
             block_cache.Remove(block.PrevHash);
             MemPool.UpdatePoolForBlockPersisted(block, currentSnapshot);
             Context.System.EventStream.Publish(new PersistCompleted { Block = block });

src/neo/Network/P2P/MessageCommand.cs

@@ -27,6 +27,8 @@ public enum MessageCommand : byte
         [ReflectionCache(typeof(GetBlocksPayload))]
         GetBlocks = 0x24,
         Mempool = 0x25,
+        [ReflectionCache(typeof(GetStateRootPayload))]
+        GetStateRoot = 0x26,
         [ReflectionCache(typeof(InvPayload))]
         Inv = 0x27,
         [ReflectionCache(typeof(InvPayload))]
@@ -40,6 +42,8 @@ public enum MessageCommand : byte
         Block = 0x2c,
         [ReflectionCache(typeof(ConsensusPayload))]
         Consensus = 0x2d,
+        [ReflectionCache(typeof(StateRoot))]
+        StateRoot = 0x2e,
         Reject = 0x2f,
 
         //SPV protocol

src/neo/Network/P2P/Payloads/GetStateRootPayload.cs

@@ -0,0 +1,30 @@
+using Neo.IO;
+using System;
+using System.IO;
+
+namespace Neo.Network.P2P.Payloads
+{
+    public class GetStateRootPayload : ISerializable
+    {
+        public uint Index;
+        public int Size => sizeof(uint);
+
+        public static GetStateRootPayload Create(uint index)
+        {
+            return new GetStateRootPayload
+            {
+                Index = index
+            };
+        }
+
+        void ISerializable.Deserialize(BinaryReader reader)
+        {
+            Index = reader.ReadUInt32();
+        }
+
+        void ISerializable.Serialize(BinaryWriter writer)
+        {
+            writer.Write(Index);
+        }
+    }
+}

src/neo/Network/P2P/Payloads/InventoryType.cs

@@ -4,6 +4,7 @@ public enum InventoryType : byte
     {
         TX = MessageCommand.Transaction,
         Block = MessageCommand.Block,
+        StateRoot = MessageCommand.StateRoot,
         Consensus = MessageCommand.Consensus
     }
 }

src/neo/Network/P2P/Payloads/StateRoot.cs

@@ -0,0 +1,123 @@
+using Neo.Cryptography;
+using Neo.IO;
+using Neo.IO.Json;
+using Neo.Ledger;
+using Neo.Persistence;
+using Neo.SmartContract;
+using Neo.SmartContract.Native;
+using System;
+using System.IO;
+
+namespace Neo.Network.P2P.Payloads
+{
+    public class StateRoot : ICloneable<StateRoot>, IInventory
+    {
+        public static readonly byte CurrentVersion = 0;
+        public byte Version;
+        public uint Index;
+        public UInt256 RootHash;
+        public Witness Witness;
+
+        InventoryType IInventory.InventoryType => InventoryType.StateRoot;
+
+        private UInt256 _hash = null;
+
+        public UInt256 Hash
+        {
+            get
+            {
+                if (_hash == null)
+                {
+                    _hash = new UInt256(Crypto.Hash256(this.GetHashData()));
+                }
+                return _hash;
+            }
+        }
+
+        Witness[] IVerifiable.Witnesses
+        {
+            get
+            {
+                return new[] { Witness };
+            }
+            set
+            {
+                if (value.Length != 1) throw new ArgumentException();
+                Witness = value[0];
+            }
+        }
+
+        public int Size =>
+            sizeof(byte) +      //Version
+            sizeof(uint) +      //Index
+            UInt256.Length +    //RootHash
+            Witness.Size;       //Witness
+
+        StateRoot ICloneable<StateRoot>.Clone()
+        {
+            return new StateRoot
+            {
+                Version = Version,
+                Index = Index,
+                RootHash = RootHash,
+                Witness = Witness,
+            };
+        }
+
+        void ICloneable<StateRoot>.FromReplica(StateRoot replica)
+        {
+            Version = replica.Version;
+            Index = replica.Index;
+            RootHash = replica.RootHash;
+            Witness = replica.Witness;
+        }
+
+        public void Deserialize(BinaryReader reader)
+        {
+            this.DeserializeUnsigned(reader);
+            Witness = reader.ReadSerializable<Witness>();
+        }
+
+        public void DeserializeUnsigned(BinaryReader reader)
+        {
+            Version = reader.ReadByte();
+            Index = reader.ReadUInt32();
+            RootHash = reader.ReadSerializable<UInt256>();
+        }
+
+        public void Serialize(BinaryWriter writer)
+        {
+            this.SerializeUnsigned(writer);
+            writer.Write(Witness);
+        }
+
+        public void SerializeUnsigned(BinaryWriter writer)
+        {
+            writer.Write(Version);
+            writer.Write(Index);
+            writer.Write(RootHash);
+        }
+
+        public bool Verify(StoreView snapshot)
+        {
+            return this.VerifyWitnesses(snapshot, 1_00000000);
+        }
+
+        public virtual UInt160[] GetScriptHashesForVerifying(StoreView snapshot)
+        {
+            var script_hash = Blockchain.Singleton.GetBlock(Index)?.NextConsensus;
+            if (script_hash is null) throw new System.InvalidOperationException("No script hash for state root verifying");
+            return new UInt160[] { script_hash };
+        }
+
+        public JObject ToJson()
+        {
+            var json = new JObject();
+            json["version"] = Version;
+            json["index"] = Index;
+            json["stateroot"] = RootHash.ToString();
+            json["witness"] = Witness.ToJson();
+            return json;
+        }
+    }
+}

src/neo/Network/P2P/RemoteNode.ProtocolHandler.cs

@@ -107,6 +107,12 @@ private void OnMessage(Message msg)
                     if (msg.Payload.Size <= Transaction.MaxTransactionSize)
                         OnInventoryReceived((Transaction)msg.Payload);
                     break;
+                case MessageCommand.StateRoot:
+                    OnRootReceived((StateRoot)msg.Payload);
+                    break;
+                case MessageCommand.GetStateRoot:
+                    OnGetRootReceived((GetStateRootPayload)msg.Payload);
+                    break;
                 case MessageCommand.Verack:
                 case MessageCommand.Version:
                     throw new ProtocolViolationException();
@@ -119,6 +125,21 @@ private void OnMessage(Message msg)
             }
         }
 
+        private void OnGetRootReceived(GetStateRootPayload payload)
+        {
+            var state_root = Blockchain.Singleton.LatestValidatorsStateRoot;
+            if (state_root is null) return;
+            if (state_root.Index < payload.Index) return;
+            EnqueueMessage(Message.Create(MessageCommand.StateRoot, state_root));
+        }
+
+        private void OnRootReceived(StateRoot payload)
+        {
+            if (knownHashes.Contains(payload.Hash)) return;
+            system.Blockchain.Tell(payload);
+            knownHashes.Add(payload.Hash);
+        }
+
         private void OnAddrMessageReceived(AddrPayload payload)
         {
             system.LocalNode.Tell(new Peer.Peers

src/neo/Network/P2P/TaskManager.cs

@@ -296,6 +296,21 @@ private void RequestTasks()
                 if (lastTaskIndex >= highestBlockIndex) break;
                 if (!AssignSyncTask(++lastTaskIndex)) break;
             }
+
+            SyncStateRoot();
+        }
+
+        private void SyncStateRoot()
+        {
+            if (Blockchain.Singleton.StateHeight + 1 < Blockchain.Singleton.Height)
+            {
+                var session = sessions.Where(p => Blockchain.Singleton.StateHeight <= p.Value.LastBlockIndex)
+                    .OrderByDescending(p => p.Value.LastBlockIndex)
+                    .ThenBy(p => p.Value.IndexTasks.Count)
+                    .FirstOrDefault();
+                if (session.Value != null)
+                    session.Key.Tell(Message.Create(MessageCommand.GetStateRoot, GetStateRootPayload.Create(Blockchain.Singleton.Height - 1)));
+            }
         }
 
         private void SendPingMessage()

src/neo/Persistence/ClonedView.cs

@@ -1,6 +1,8 @@
+using Neo.Cryptography.MPT;
 using Neo.IO;
 using Neo.IO.Caching;
 using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
 
 namespace Neo.Persistence
 {
@@ -11,8 +13,10 @@ internal class ClonedView : StoreView
         public override DataCache<UInt160, ContractState> Contracts { get; }
         public override DataCache<StorageKey, StorageItem> Storages { get; }
         public override DataCache<SerializableWrapper<uint>, HeaderHashList> HeaderHashList { get; }
+        public override DataCache<SerializableWrapper<uint>, HashIndexState> LocalStateRoot { get; }
         public override MetaDataCache<HashIndexState> BlockHashIndex { get; }
         public override MetaDataCache<HashIndexState> HeaderHashIndex { get; }
+        public override MetaDataCache<StateRoot> ValidatorsStateRoot { get; }
         public override MetaDataCache<ContractIdState> ContractId { get; }
 
         public ClonedView(StoreView view)
@@ -23,8 +27,10 @@ public ClonedView(StoreView view)
             this.Contracts = view.Contracts.CreateSnapshot();
             this.Storages = view.Storages.CreateSnapshot();
             this.HeaderHashList = view.HeaderHashList.CreateSnapshot();
+            this.LocalStateRoot = view.LocalStateRoot.CreateSnapshot();
             this.BlockHashIndex = view.BlockHashIndex.CreateSnapshot();
             this.HeaderHashIndex = view.HeaderHashIndex.CreateSnapshot();
+            this.ValidatorsStateRoot = view.ValidatorsStateRoot.CreateSnapshot();
             this.ContractId = view.ContractId.CreateSnapshot();
         }
     }

src/neo/Persistence/Helper.cs

@@ -1,4 +1,5 @@
 using System;
+using Neo.Ledger;
 
 namespace Neo.Persistence
 {
@@ -8,5 +9,13 @@ public static byte[] EnsureNotNull(this byte[] source)
         {
             return source ?? Array.Empty<byte>();
         }
+
+        public static void UpdateLocalStateRoot(this SnapshotView snapshot)
+        {
+            snapshot.Storages.Commit();
+            var root = snapshot.LocalStateRoot.GetAndChange(snapshot.Height, () => new HashIndexState());
+            root.Index = snapshot.Height;
+            root.Hash = ((MPTDataCache<StorageKey, StorageItem>)snapshot.Storages).Root.Hash;
+        }
     }
 }