[neox] persistence

src/neo/Cryptography/MPT/MPTTrie.cs

@@ -18,7 +18,7 @@ public partial class MPTTrie<TKey, TValue>
         public MPTTrie(ISnapshot store, UInt256 root)
         {
             this.store = store ?? throw new ArgumentNullException();
-            this.root = root is null ? HashNode.EmptyNode : new HashNode(root);
+            this.root = root is null || root == UInt256.Zero ? HashNode.EmptyNode : new HashNode(root);
         }
 
         private MPTNode Resolve(HashNode n)
@@ -54,5 +54,10 @@ private void PutToStore(MPTNode node)
         {
             store.Put(Prefix, node.Hash.ToArray(), node.Encode());
         }
+
+        public MPTTrie<TKey, TValue> Clone()
+        {
+            return new MPTTrie<TKey, TValue>(store, root.Hash);
+        }
     }
 }

src/neo/Ledger/HashState.cs

@@ -0,0 +1,41 @@
+using Neo.IO;
+using Neo.Network.P2P.Payloads;
+using System.IO;
+
+namespace Neo.Ledger
+{
+    public class HashState : ICloneable<HashState>, ISerializable
+    {
+        public UInt256 Hash = UInt256.Zero;
+
+        int ISerializable.Size => Hash.Size;
+
+        HashState ICloneable<HashState>.Clone()
+        {
+            return new HashState
+            {
+                Hash = Hash
+            };
+        }
+
+        void ISerializable.Deserialize(BinaryReader reader)
+        {
+            Hash = reader.ReadSerializable<UInt256>();
+        }
+
+        void ICloneable<HashState>.FromReplica(HashState replica)
+        {
+            Hash = replica.Hash;
+        }
+
+        void ISerializable.Serialize(BinaryWriter writer)
+        {
+            writer.Write(Hash);
+        }
+
+        internal void Set(BlockBase block)
+        {
+            Hash = block.Hash;
+        }
+    }
+}

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,127 @@
+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) +
+            sizeof(uint) +
+            UInt256.Length +
+            Witness.Size;
+
+        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,
+                ApplicationEngine.ECDsaVerifyPrice * (NativeContract.NEO.GetValidators(Blockchain.Singleton.GetSnapshot()).Length + 1));
+        }
+
+        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,31 +1,44 @@
+using Neo.Cryptography.MPT;
 using Neo.IO;
 using Neo.IO.Caching;
 using Neo.Ledger;
+using Neo.Network.P2P.Payloads;
 
 namespace Neo.Persistence
 {
     internal class ClonedView : StoreView
     {
+        private StoreView parent;
         public override DataCache<UInt256, TrimmedBlock> Blocks { get; }
         public override DataCache<UInt256, TransactionState> Transactions { get; }
         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>, HashState> LocalStateRoot { get; }
         public override MetaDataCache<HashIndexState> BlockHashIndex { get; }
         public override MetaDataCache<HashIndexState> HeaderHashIndex { get; }
+        public override MetaDataCache<StateRoot> ConfirmedStateRootHashIndex { get; }
         public override MetaDataCache<ContractIdState> ContractId { get; }
 
         public ClonedView(StoreView view)
         {
+            this.parent = view;
             this.PersistingBlock = view.PersistingBlock;
             this.Blocks = view.Blocks.CreateSnapshot();
             this.Transactions = view.Transactions.CreateSnapshot();
             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.ConfirmedStateRootHashIndex = view.ConfirmedStateRootHashIndex.CreateSnapshot();
             this.ContractId = view.ContractId.CreateSnapshot();
+            this.Storages = view.Storages.Clone();
+        }
+
+        public override void Commit()
+        {
+            base.Commit();
+            parent.Storages = Storages;
         }
     }
 }

src/neo/Persistence/Prefixes.cs

@@ -7,11 +7,14 @@ internal static class Prefixes
 
         public const byte ST_Contract = 0x50;
         public const byte ST_Storage = 0x70;
+        public const byte ST_Root = 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_CurrentRoot = 0xc3;
+        public const byte IX_ConfirmedRoot = 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,11 +17,13 @@ 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<SerializableWrapper<uint>, HeaderHashList> HeaderHashList => new StoreDataCache<SerializableWrapper<uint>, HeaderHashList>(store, Prefixes.IX_HeaderHashList);
+        public override DataCache<SerializableWrapper<uint>, HashState> LocalStateRoot => new StoreDataCache<SerializableWrapper<uint>, HashState>(store, Prefixes.ST_Root);
         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> ConfirmedStateRootHashIndex => new StoreMetaDataCache<StateRoot>(store, Prefixes.IX_ConfirmedRoot);
         public override MetaDataCache<ContractIdState> ContractId => new StoreMetaDataCache<ContractIdState>(store, Prefixes.IX_ContractId);
+        public new MPTTrie<StorageKey, StorageItem> Storages => new MPTTrie<StorageKey, StorageItem>((ISnapshot)store, CurrentStateRootHash);
 
         public ReadOnlyView(IReadOnlyStore store)
         {

src/neo/Persistence/SnapshotView.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,11 @@ public class SnapshotView : StoreView, IDisposable
         public override DataCache<UInt256, TrimmedBlock> Blocks { get; }
         public override DataCache<UInt256, TransactionState> Transactions { get; }
         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>, HashState> LocalStateRoot { get; }
         public override MetaDataCache<HashIndexState> BlockHashIndex { get; }
         public override MetaDataCache<HashIndexState> HeaderHashIndex { get; }
+        public override MetaDataCache<StateRoot> ConfirmedStateRootHashIndex { get; }
         public override MetaDataCache<ContractIdState> ContractId { get; }
 
         public SnapshotView(IStore store)
@@ -27,15 +30,27 @@ 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>, HashState>(snapshot, Prefixes.ST_Root);
             BlockHashIndex = new StoreMetaDataCache<HashIndexState>(snapshot, Prefixes.IX_CurrentBlock);
             HeaderHashIndex = new StoreMetaDataCache<HashIndexState>(snapshot, Prefixes.IX_CurrentHeader);
             ContractId = new StoreMetaDataCache<ContractIdState>(snapshot, Prefixes.IX_ContractId);
+            ConfirmedStateRootHashIndex = new StoreMetaDataCache<StateRoot>(snapshot, Prefixes.IX_ConfirmedRoot);
+            Storages = new MPTTrie<StorageKey, StorageItem>(snapshot, CurrentStateRootHash);
+        }
+
+        private void PreCommit()
+        {
+            var index = PersistingBlock?.Index ?? Height;
+            if (LocalStateRoot.TryGet(index) is null || LocalStateRoot.TryGet(index).Hash != Storages.Root.Hash)
+            {
+                LocalStateRoot.GetAndChange(index, () => new HashState()).Hash = Storages.Root.Hash;
+            }
         }
 
         public override void Commit()
         {
+            PreCommit();
             base.Commit();
             snapshot.Commit();
         }

src/neo/Persistence/StoreView.cs

@@ -1,3 +1,4 @@
+using Neo.Cryptography.MPT;
 using Neo.IO;
 using Neo.IO.Caching;
 using Neo.Ledger;
@@ -14,17 +15,21 @@ public abstract class StoreView
         public abstract DataCache<UInt256, TrimmedBlock> Blocks { get; }
         public abstract DataCache<UInt256, TransactionState> Transactions { get; }
         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>, HashState> LocalStateRoot { get; }
         public abstract MetaDataCache<HashIndexState> BlockHashIndex { get; }
         public abstract MetaDataCache<HashIndexState> HeaderHashIndex { get; }
+        public abstract MetaDataCache<StateRoot> ConfirmedStateRootHashIndex { get; }
         public abstract MetaDataCache<ContractIdState> ContractId { get; }
+        public MPTTrie<StorageKey, StorageItem> Storages;
 
         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()
         {
             return new ClonedView(this);
@@ -35,11 +40,12 @@ public virtual void Commit()
             Blocks.Commit();
             Transactions.Commit();
             Contracts.Commit();
-            Storages.Commit();
             HeaderHashList.Commit();
+            LocalStateRoot.Commit();
             BlockHashIndex.Commit();
             HeaderHashIndex.Commit();
             ContractId.Commit();
+            ConfirmedStateRootHashIndex.Commit();
         }
 
         public bool ContainsBlock(UInt256 hash)