97237802

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/neo-project/neo/commit/<a class=hub.com/neo-project/neo/commit/<a class="double-link" href="https://git"><a class=hub.com/neo-project/neo/commit/<a class="double-link" href="https://git"><a class=hub.com/neo-project/neo/commit/<a class="double-link" href="https://git"><a class=hub.com/neo-project/neo/commit/<a class="double-link" href="https://git"><a class=hub.com/neo-project/neo/commit/b99aba77dcf5e094fbb1313a901af8296126a227">b99aba77d">&lt;a href=&quot;https://github.com/neo-project/neo/commit/</a><a class="double-link" href="https://github.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/neo-project/neo/commit/b99aba77dcf5e094fbb1313a901af8296126a227">b99aba77d</a><a href="https://github.com/neo-project/neo/commit/b99aba77dcf5e094fbb1313a901af8296126a227">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/neo-project/neo/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/neo-project/neo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/neo-project/neo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/neo-project/neo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/neo-project/neo/commit/b99aba77dcf5e094fbb1313a901af8296126a227&quot;&gt;b99aba77d&lt;/a&gt;&lt;a href=&quot;https://github.com/neo-project/neo/commit/b99aba77dcf5e094fbb1313a901af8296126a227&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/neo-project/neo/commit/b99aba77dcf5e094fbb1313a901af8296126a227&amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;&amp;amp;amp;lt;a href=&amp;amp;amp;quot;https://github.com/neo-project/neo/commit/&amp;amp;lt;/a&amp;amp;gt;&amp;amp;lt;a class=&amp;amp;quot;doub... (continued)

Pull Request Pull Request #1598: [neox-2.x] root generate, sync and verify

Run Details

1068 of 5350 branches covered (19.96%)

Branch coverage included in aggregate %.

169 of 169 new or added lines in 6 files covered. (100.0%)

4580 of 15066 relevant lines covered (30.4%)

3590.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

22.75

/neo/Ledger/BlockChain.State.cs

using Akka.Actor;
using Neo.IO;
using Neo.Network.P2P;
using Neo.Network.P2P.Payloads;
using Neo.Persistence;
using Neo.Persistence.LevelDB;
using Neo.Trie.MPT;
using System;
using System.Collections.Generic;

namespace Neo.Ledger
{
    public sealed partial class Blockchain : UntypedActor
    {
        public class ImportRoots { public IEnumerable<StateRoot> Roots; }
        public uint StateHeight => currentSnapshot.StateHeight;
        private static uint StateRootEnableIndex => ProtocolSettings.Default.StateRootEnableIndex;
        private readonly Dictionary<uint, StateRoot> stateRootCache = new Dictionary<uint, StateRoot>();

        public StateRootState GetStateRoot(UInt256 block_hash)
        {
            var block = GetBlock(block_hash);
            return block is null ? null : GetStateRoot(block.Index);
        }

        public StateRootState GetStateRoot(uint index)
        {
            return currentSnapshot.StateRoots.TryGet(index);
        }

        public bool GetStateProof(UInt256 root, StorageKey skey, out HashSet<byte[]> proof)
        {
            var trieReadOnlyDb = new TrieReadOnlyStore(Store, Prefixes.DATA_MPT);
            var readOnlyTrie = new MPTReadOnlyTrie(root, trieReadOnlyDb);
            return readOnlyTrie.GetProof(skey.ToArray(), out proof);
        }

        public bool VerifyProof(UInt256 root, byte[] key, HashSet<byte[]> proof, out byte[] value)
        {
            var result = MPTTrie.VerifyProof(root, key, proof, out value);
            if (result) value = value.AsSerializable<StorageItem>().Value;
            return result;
        }

        private RelayResultReason OnNewStateRoot(StateRoot stateRoot)
        {
            if (stateRoot.Index < StateRootEnableIndex || stateRoot.Index <= StateHeight) return RelayResultReason.Invalid;
            if (!stateRoot.Verify(currentSnapshot)) return RelayResultReason.Invalid;
            if (stateRootCache.ContainsKey(stateRoot.Index)) return RelayResultReason.AlreadyExists;
            if (stateRoot.Index > StateHeight + 1 && stateRoot.Index != StateRootEnableIndex)
            {
                stateRootCache.Add(stateRoot.Index, stateRoot);
                return RelayResultReason.Succeed;
            }
            using (Snapshot snapshot = GetSnapshot())
            {
                while (stateRoot.Index <= Height)
                {
                    if (PersistCnStateRoot(stateRoot) == StateRootVerifyFlag.Invalid)
                        break;

                    if (stateRoot.Index + 3 > HeaderHeight)
                    {// TODO remove +3 and use LocalNode.RelayDirectly
                        system.LocalNode.Tell(new LocalNode.SendDirectly { Inventory = stateRoot });
                    }

                    stateRootCache.Remove(stateRoot.Index);
                    if (!stateRootCache.TryGetValue(stateRoot.Index + 1, out stateRoot)) break;
                }
            }
            return RelayResultReason.Succeed;
        }

        private void OnStateRoots(StateRoot[] sts)
        {
            foreach (var state_root in sts)
            {
                var result = OnNewStateRoot(state_root);
                if (result != RelayResultReason.Succeed)
                    break;
            }
            system.TaskManager.Tell(new TaskManager.StateRootTaskCompleted(), Sender);
        }

        private void OnImportRoots(IEnumerable<StateRoot> roots)
        {
            foreach (StateRoot stateRoot in roots)
            {
                if (stateRoot.Index < Math.Max(StateHeight, StateRootEnableIndex)) continue;
                if (stateRoot.Index != Math.Max(StateHeight + 1, StateRootEnableIndex))
                    throw new InvalidOperationException();

                if (PersistCnStateRoot(stateRoot) == StateRootVerifyFlag.Invalid)
                    break;
            }
            Sender.Tell(new ImportCompleted());
        }

        private StateRootVerifyFlag PersistCnStateRoot(StateRoot stateRoot)
        {
            using (Snapshot snapshot = GetSnapshot())
            {
                var localState = snapshot.StateRoots.GetAndChange(stateRoot.Index);
                if (localState.StateRoot.Root == stateRoot.Root && localState.StateRoot.PreHash == stateRoot.PreHash)
                {
                    HashIndexState hashIndexState = snapshot.StateRootHashIndex.GetAndChange();
                    hashIndexState.Index = stateRoot.Index;
                    hashIndexState.Hash = stateRoot.Hash;
                    localState.StateRoot = stateRoot;
                    localState.Flag = StateRootVerifyFlag.Verified;
                }
                else
                {
                    localState.Flag = StateRootVerifyFlag.Invalid;
                }
                snapshot.Commit();
                UpdateCurrentSnapshot();

                return localState.Flag;
            }
        }

        private void PersistLocalStateRoot()
        {
            using (Snapshot snapshot = GetSnapshot())
            {
                var trie_db = new TrieReadOnlyStore(Store, Prefixes.DATA_MPT);
                var current_root = trie_db.GetRoot();
                var current_index = snapshot.Height;
                var pre_hash = UInt256.Zero;
                if (current_index > 0)
                {
                    var last_state_root = currentSnapshot.StateRoots.TryGet(current_index - 1);
                    pre_hash = last_state_root.StateRoot.Hash;
                }

                var state_root = new StateRoot
                {
                    Version = MPTTrie.Version,
                    Index = current_index,
                    PreHash = pre_hash,
                    Root = current_root,
                };
                var state_root_state = new StateRootState
                {
                    Flag = StateRootVerifyFlag.Unverified,
                    StateRoot = state_root,
                };
                snapshot.StateRoots.Add(current_index, state_root_state);
                snapshot.Commit();
            }
        }

        private void CheckRootOnBlockPersistCompleted()
        {
            var index = Math.Max(StateHeight + 1, StateRootEnableIndex);
            if (GetStateRoot(index)?.Flag == StateRootVerifyFlag.Unverified && stateRootCache.TryGetValue(index, out StateRoot state_root))
            {
                stateRootCache.Remove(index);
                Self.Tell(state_root);
            }
        }
    }
}

1	using Akka.Actor;
2	using Neo.IO;
3	using Neo.Network.P2P;
4	using Neo.Network.P2P.Payloads;
5	using Neo.Persistence;
6	using Neo.Persistence.LevelDB;
7	using Neo.Trie.MPT;
8	using System;
9	using System.Collections.Generic;
10
11	namespace Neo.Ledger
12	{
13	public sealed partial class Blockchain : UntypedActor
14	{
15	public class ImportRoots { public IEnumerable<StateRoot> Roots; }
16	public uint StateHeight => currentSnapshot.StateHeight;	1✔
17	private static uint StateRootEnableIndex => ProtocolSettings.Default.StateRootEnableIndex;	1✔
18	private readonly Dictionary<uint, StateRoot> stateRootCache = new Dictionary<uint, StateRoot>();	1✔
19
20	public StateRootState GetStateRoot(UInt256 block_hash)
21	{	×
22	var block = GetBlock(block_hash);	×
23	return block is null ? null : GetStateRoot(block.Index);	×
24	}	×
25
26	public StateRootState GetStateRoot(uint index)
27	{	1✔
28	return currentSnapshot.StateRoots.TryGet(index);	1✔
29	}	1✔
30
31	public bool GetStateProof(UInt256 root, StorageKey skey, out HashSet<byte[]> proof)
32	{	×
33	var trieReadOnlyDb = new TrieReadOnlyStore(Store, Prefixes.DATA_MPT);	×
34	var readOnlyTrie = new MPTReadOnlyTrie(root, trieReadOnlyDb);	×
35	return readOnlyTrie.GetProof(skey.ToArray(), out proof);	×
36	}	×
37
38	public bool VerifyProof(UInt256 root, byte[] key, HashSet<byte[]> proof, out byte[] value)
39	{	×
40	var result = MPTTrie.VerifyProof(root, key, proof, out value);	×
41	if (result) value = value.AsSerializable<StorageItem>().Value;	×
42	return result;	×
43	}	×
44
45	private RelayResultReason OnNewStateRoot(StateRoot stateRoot)
46	{	×
47	if (stateRoot.Index < StateRootEnableIndex \|\| stateRoot.Index <= StateHeight) return RelayResultReason.Invalid;	×
48	if (!stateRoot.Verify(currentSnapshot)) return RelayResultReason.Invalid;	×
49	if (stateRootCache.ContainsKey(stateRoot.Index)) return RelayResultReason.AlreadyExists;	×
50	if (stateRoot.Index > StateHeight + 1 && stateRoot.Index != StateRootEnableIndex)	×
51	{	×
52	stateRootCache.Add(stateRoot.Index, stateRoot);	×
53	return RelayResultReason.Succeed;	×
54	}
55	using (Snapshot snapshot = GetSnapshot())	×
56	{	×
57	while (stateRoot.Index <= Height)	×
58	{	×
59	if (PersistCnStateRoot(stateRoot) == StateRootVerifyFlag.Invalid)	×
60	break;	×
61
62	if (stateRoot.Index + 3 > HeaderHeight)	×
63	{// TODO remove +3 and use LocalNode.RelayDirectly	×
64	system.LocalNode.Tell(new LocalNode.SendDirectly { Inventory = stateRoot });	×
65	}	×
66
67	stateRootCache.Remove(stateRoot.Index);	×
68	if (!stateRootCache.TryGetValue(stateRoot.Index + 1, out stateRoot)) break;	×
69	}	×
70	}	×
71	return RelayResultReason.Succeed;	×
72	}	×
73
74	private void OnStateRoots(StateRoot[] sts)
75	{	×
76	foreach (var state_root in sts)	×
77	{	×
78	var result = OnNewStateRoot(state_root);	×
79	if (result != RelayResultReason.Succeed)	×
80	break;	×
81	}	×
82	system.TaskManager.Tell(new TaskManager.StateRootTaskCompleted(), Sender);	×
83	}	×
84
85	private void OnImportRoots(IEnumerable<StateRoot> roots)
86	{	×
87	foreach (StateRoot stateRoot in roots)	×
88	{	×
89	if (stateRoot.Index < Math.Max(StateHeight, StateRootEnableIndex)) continue;	×
90	if (stateRoot.Index != Math.Max(StateHeight + 1, StateRootEnableIndex))	×
91	throw new InvalidOperationException();	×
92
93	if (PersistCnStateRoot(stateRoot) == StateRootVerifyFlag.Invalid)	×
94	break;	×
95	}	×
96	Sender.Tell(new ImportCompleted());	×
97	}	×
98
99	private StateRootVerifyFlag PersistCnStateRoot(StateRoot stateRoot)
100	{	×
101	using (Snapshot snapshot = GetSnapshot())	×
102	{	×
103	var localState = snapshot.StateRoots.GetAndChange(stateRoot.Index);	×
104	if (localState.StateRoot.Root == stateRoot.Root && localState.StateRoot.PreHash == stateRoot.PreHash)	×
105	{	×
106	HashIndexState hashIndexState = snapshot.StateRootHashIndex.GetAndChange();	×
107	hashIndexState.Index = stateRoot.Index;	×
108	hashIndexState.Hash = stateRoot.Hash;	×
109	localState.StateRoot = stateRoot;	×
110	localState.Flag = StateRootVerifyFlag.Verified;	×
111	}	×
112	else
113	{	×
114	localState.Flag = StateRootVerifyFlag.Invalid;	×
115	}	×
116	snapshot.Commit();	×
117	UpdateCurrentSnapshot();	×
118
119	return localState.Flag;	×
120	}
121	}	×
122
123	private void PersistLocalStateRoot()
124	{	1✔
125	using (Snapshot snapshot = GetSnapshot())	1✔
126	{	1✔
127	var trie_db = new TrieReadOnlyStore(Store, Prefixes.DATA_MPT);	1✔
128	var current_root = trie_db.GetRoot();	1✔
129	var current_index = snapshot.Height;	1✔
130	var pre_hash = UInt256.Zero;	1✔
131	if (current_index > 0)	1!
132	{	×
133	var last_state_root = currentSnapshot.StateRoots.TryGet(current_index - 1);	×
134	pre_hash = last_state_root.StateRoot.Hash;	×
135	}	×
136
137	var state_root = new StateRoot	1✔
138	{	1✔
139	Version = MPTTrie.Version,	1✔
140	Index = current_index,	1✔
141	PreHash = pre_hash,	1✔
142	Root = current_root,	1✔
143	};	1✔
144	var state_root_state = new StateRootState	1✔
145	{	1✔
146	Flag = StateRootVerifyFlag.Unverified,	1✔
147	StateRoot = state_root,	1✔
148	};	1✔
149	snapshot.StateRoots.Add(current_index, state_root_state);	1✔
150	snapshot.Commit();	1✔
151	}	1✔
152	}	1✔
153
154	private void CheckRootOnBlockPersistCompleted()
155	{	1✔
156	var index = Math.Max(StateHeight + 1, StateRootEnableIndex);	1✔
157	if (GetStateRoot(index)?.Flag == StateRootVerifyFlag.Unverified && stateRootCache.TryGetValue(index, out StateRoot state_root))	1!
158	{	×
159	stateRootCache.Remove(index);	×
160	Self.Tell(state_root);	×
161	}	×
162	}	1✔
163	}
164	}

neo-project / neo / 97237802

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous