[neox] persistence

src/neo/Cryptography/MPT/MPTTrie.Proof.cs

@@ -61,11 +61,12 @@ private bool GetProof(ref MPTNode node, ReadOnlySpan<byte> path, HashSet<byte[]>
 
         public static TValue VerifyProof(UInt256 root, TKey key, HashSet<byte[]> proof)
         {
+            const byte proof_prefix = 0x00;
             using var memoryStore = new MemoryStore();
             foreach (byte[] data in proof)
-                memoryStore.Put(Prefix, Crypto.Hash256(data), data);
+                memoryStore.Put(proof_prefix, Crypto.Hash256(data), data);
             using ISnapshot snapshot = memoryStore.GetSnapshot();
-            var trie = new MPTTrie<TKey, TValue>(snapshot, root);
+            var trie = new MPTTrie<TKey, TValue>(snapshot, proof_prefix, root);
             return trie[key];
         }
     }

src/neo/Cryptography/MPT/MPTTrie.cs

@@ -8,17 +8,18 @@ public partial class MPTTrie<TKey, TValue>
         where TKey : notnull, ISerializable, new()
         where TValue : class, ISerializable, new()
     {
-        private const byte Prefix = 0xf0;
+        private byte Prefix;
 
         private readonly ISnapshot store;
         private MPTNode root;
 
         public MPTNode Root => root;
 
-        public MPTTrie(ISnapshot store, UInt256 root)
+        public MPTTrie(ISnapshot store, byte prefix, UInt256 root)
         {
             this.store = store ?? throw new ArgumentNullException();
-            this.root = root is null ? HashNode.EmptyNode : new HashNode(root);
+            this.Prefix = prefix;
+            this.root = root is null || root == UInt256.Zero ? HashNode.EmptyNode : new HashNode(root);
         }
 
         private MPTNode Resolve(HashNode n)

src/neo/Network/P2P/MessageCommand.cs

@@ -40,6 +40,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/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,126 @@
+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 byte Version;
+        public uint Index;
+        public UInt256 Root;
+        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 +        //Root
+            Witness.Size;           //Witness
+
+        StateRoot ICloneable<StateRoot>.Clone()
+        {
+            return new StateRoot
+            {
+                Version = Version,
+                Index = Index,
+                Root = Root,
+                Witness = Witness,
+            };
+        }
+
+        void ICloneable<StateRoot>.FromReplica(StateRoot replica)
+        {
+            Version = replica.Version;
+            Index = replica.Index;
+            Root = replica.Root;
+            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();
+            Root = 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(Root);
+        }
+
+        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;
+            return script_hash is null ? Array.Empty<UInt160>() : new UInt160[] { script_hash };
+        }
+
+        public byte[] GetMessage()
+        {
+            return this.GetHashData();
+        }
+
+        public JObject ToJson()
+        {
+            var json = new JObject();
+            json["version"] = Version;
+            json["index"] = Index;
+            json["stateroot"] = Root.ToString();
+            json["witness"] = Witness.ToJson();
+            return json;
+        }
+    }
+}

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/MPTDataCache.cs

@@ -0,0 +1,53 @@
+
+using Neo.Cryptography.MPT;
+using Neo.IO;
+using Neo.IO.Caching;
+using System;
+using System.Collections.Generic;
+
+namespace Neo.Persistence
+{
+    internal class MPTDataCache<TKey, TValue> : DataCache<TKey, TValue>
+    where TKey : IEquatable<TKey>, ISerializable, new()
+    where TValue : class, ICloneable<TValue>, ISerializable, new()
+    {
+        private MPTTrie<TKey, TValue> mptTrie;
+
+        public MPTNode Root => mptTrie.Root;
+
+        public MPTDataCache(IReadOnlyStore store, byte prefix, UInt256 root)
+        {
+            mptTrie = new MPTTrie<TKey, TValue>(store as ISnapshot, prefix, root);
+        }
+
+        protected override void AddInternal(TKey key, TValue value)
+        {
+            mptTrie.Put(key, value);
+        }
+
+        protected override void DeleteInternal(TKey key)
+        {
+            mptTrie.Delete(key);
+        }
+
+        protected override IEnumerable<(TKey Key, TValue Value)> FindInternal(byte[] key_prefix)
+        {
+            return mptTrie.Find(key_prefix);
+        }
+
+        protected override TValue GetInternal(TKey key)
+        {
+            return mptTrie[key];
+        }
+
+        protected override TValue TryGetInternal(TKey key)
+        {
+            return mptTrie[key];
+        }
+
+        protected override void UpdateInternal(TKey key, TValue value)
+        {
+            mptTrie.Put(key, value);
+        }
+    }
+}

src/neo/Persistence/Prefixes.cs

@@ -7,11 +7,13 @@ internal static class Prefixes
 
         public const byte ST_Contract = 0x50;
         public const byte ST_Storage = 0x70;
+        public const byte ST_LocalStateRoot = 0x60;
 
         public const byte IX_HeaderHashList = 0x80;
         public const byte IX_CurrentBlock = 0xc0;
         public const byte IX_CurrentHeader = 0xc1;
         public const byte IX_ContractId = 0xc2;
+        public const byte IX_ValidatorsStateRoot = 0xc4;
 
         /* Prefixes 0xf0 to 0xff are reserved for external use.
          *

src/neo/Persistence/ReadOnlyView.cs

@@ -1,6 +1,8 @@
+using Neo.Cryptography.MPT;
 using Neo.IO;
 using Neo.IO.Caching;
 using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
 using System;
 
 namespace Neo.Persistence
@@ -15,10 +17,12 @@ public class ReadOnlyView : StoreView
         public override DataCache<UInt256, TrimmedBlock> Blocks => new StoreDataCache<UInt256, TrimmedBlock>(store, Prefixes.DATA_Block);
         public override DataCache<UInt256, TransactionState> Transactions => new StoreDataCache<UInt256, TransactionState>(store, Prefixes.DATA_Transaction);
         public override DataCache<UInt160, ContractState> Contracts => new StoreDataCache<UInt160, ContractState>(store, Prefixes.ST_Contract);
-        public override DataCache<StorageKey, StorageItem> Storages => new StoreDataCache<StorageKey, StorageItem>(store, Prefixes.ST_Storage);
+        public override DataCache<StorageKey, StorageItem> Storages => new MPTDataCache<StorageKey, StorageItem>(store, Prefixes.ST_Storage, CurrentStateRootHash);
         public override DataCache<SerializableWrapper<uint>, HeaderHashList> HeaderHashList => new StoreDataCache<SerializableWrapper<uint>, HeaderHashList>(store, Prefixes.IX_HeaderHashList);
+        public override DataCache<SerializableWrapper<uint>, HashIndexState> LocalStateRoot => new StoreDataCache<SerializableWrapper<uint>, HashIndexState>(store, Prefixes.ST_LocalStateRoot);
         public override MetaDataCache<HashIndexState> BlockHashIndex => new StoreMetaDataCache<HashIndexState>(store, Prefixes.IX_CurrentBlock);
         public override MetaDataCache<HashIndexState> HeaderHashIndex => new StoreMetaDataCache<HashIndexState>(store, Prefixes.IX_CurrentHeader);
+        public override MetaDataCache<StateRoot> ValidatorsStateRoot => new StoreMetaDataCache<StateRoot>(store, Prefixes.IX_ValidatorsStateRoot);
         public override MetaDataCache<ContractIdState> ContractId => new StoreMetaDataCache<ContractIdState>(store, Prefixes.IX_ContractId);
 
         public ReadOnlyView(IReadOnlyStore store)

src/neo/Persistence/SnapshotView.cs

@@ -1,6 +1,7 @@
 using Neo.IO;
 using Neo.IO.Caching;
 using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
 using System;
 
 namespace Neo.Persistence
@@ -17,8 +18,10 @@ public class SnapshotView : StoreView, IDisposable
         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 SnapshotView(IStore store)
@@ -27,16 +30,22 @@ public SnapshotView(IStore store)
             Blocks = new StoreDataCache<UInt256, TrimmedBlock>(snapshot, Prefixes.DATA_Block);
             Transactions = new StoreDataCache<UInt256, TransactionState>(snapshot, Prefixes.DATA_Transaction);
             Contracts = new StoreDataCache<UInt160, ContractState>(snapshot, Prefixes.ST_Contract);
-            Storages = new StoreDataCache<StorageKey, StorageItem>(snapshot, Prefixes.ST_Storage);
             HeaderHashList = new StoreDataCache<SerializableWrapper<uint>, HeaderHashList>(snapshot, Prefixes.IX_HeaderHashList);
+            LocalStateRoot = new StoreDataCache<SerializableWrapper<uint>, HashIndexState>(snapshot, Prefixes.ST_LocalStateRoot);
             BlockHashIndex = new StoreMetaDataCache<HashIndexState>(snapshot, Prefixes.IX_CurrentBlock);
             HeaderHashIndex = new StoreMetaDataCache<HashIndexState>(snapshot, Prefixes.IX_CurrentHeader);
             ContractId = new StoreMetaDataCache<ContractIdState>(snapshot, Prefixes.IX_ContractId);
+            ValidatorsStateRoot = new StoreMetaDataCache<StateRoot>(snapshot, Prefixes.IX_ValidatorsStateRoot);
+            Storages = new MPTDataCache<StorageKey, StorageItem>(snapshot, Prefixes.ST_Storage, CurrentStateRootHash);//Need BlockHashIndex and LocalStateRoot loaded.
         }
 
         public override void Commit()
         {
             base.Commit();
+            var root = LocalStateRoot.GetAndChange(Height, () => new HashIndexState());
+            root.Index = Height;
+            root.Hash = ((MPTDataCache<StorageKey, StorageItem>)Storages).Root.Hash;
+            LocalStateRoot.Commit();
             snapshot.Commit();
         }
 

src/neo/Persistence/StoreView.cs

@@ -16,13 +16,16 @@ public abstract class StoreView
         public abstract DataCache<UInt160, ContractState> Contracts { get; }
         public abstract DataCache<StorageKey, StorageItem> Storages { get; }
         public abstract DataCache<SerializableWrapper<uint>, HeaderHashList> HeaderHashList { get; }
+        public abstract DataCache<SerializableWrapper<uint>, HashIndexState> LocalStateRoot { get; }
         public abstract MetaDataCache<HashIndexState> BlockHashIndex { get; }
         public abstract MetaDataCache<HashIndexState> HeaderHashIndex { get; }
+        public abstract MetaDataCache<StateRoot> ValidatorsStateRoot { get; }
         public abstract MetaDataCache<ContractIdState> ContractId { get; }
 
         public uint Height => BlockHashIndex.Get().Index;
         public uint HeaderHeight => HeaderHashIndex.Get().Index;
         public UInt256 CurrentBlockHash => BlockHashIndex.Get().Hash;
+        public UInt256 CurrentStateRootHash => LocalStateRoot.TryGet(Height)?.Hash ?? UInt256.Zero;
         public UInt256 CurrentHeaderHash => HeaderHashIndex.Get().Hash;
 
         public StoreView Clone()
@@ -37,9 +40,11 @@ public virtual void Commit()
             Contracts.Commit();
             Storages.Commit();
             HeaderHashList.Commit();
+            LocalStateRoot.Commit();
             BlockHashIndex.Commit();
             HeaderHashIndex.Commit();
             ContractId.Commit();
+            ValidatorsStateRoot.Commit();
         }
 
         public bool ContainsBlock(UInt256 hash)