Add MPT

src/neo/Trie/MPT/Helper.cs

@@ -0,0 +1,72 @@
+using System;
+
+namespace Neo.Trie.MPT
+{
+    public static class Helper
+    {
+        public static byte[] Concat(this byte[] a, byte[] b)
+        {
+            var result = new byte[a.Length + b.Length];
+            a.CopyTo(result, 0);
+            b.CopyTo(result, a.Length);
+            return result;
+        }
+
+        public static byte[] CommonPrefix(this byte[] a, byte[] b)
+        {
+            var prefix = new byte[] { };
+            var minLen = a.Length <= b.Length ? a.Length : b.Length;
+
+            if (a.Length != 0 && b.Length != 0)
+            {
+                for (int i = 0; i < minLen; i++)
+                {
+                    if (a[i] != b[i]) break;
+                    prefix = prefix.Add(a[i]);
+                }
+            }
+            return prefix;
+        }
+
+        public static bool Equal(this byte[] a, byte[] b)
+        {
+            if (a.Length != b.Length) return false;
+            for (int i = 0; i < a.Length; i++)
+            {
+                if (a[i] != b[i]) return false;
+            }
+            return true;
+        }
+
+        public static byte[] Skip(this byte[] a, int count)
+        {
+            var result = new byte[] { };
+            var len = a.Length - count;
+            if (0 < len)
+            {
+                result = new byte[len];
+                Array.Copy(a, count, result, 0, len);
+            }
+            return result;
+        }
+
+        public static byte[] Add(this byte[] a, byte b)
+        {
+            var result = new byte[a.Length + 1];
+            a.CopyTo(result, 0);
+            result[a.Length] = b;
+            return result;
+        }
+
+        public static byte[] ToNibbles(this byte[] path)
+        {
+            var result = new byte[path.Length * 2];
+            for (int i = 0; i < path.Length; i++)
+            {
+                result[i * 2] = (byte)(path[i] >> 4);
+                result[i * 2 + 1] = (byte)(path[i] & 0x0F);
+            }
+            return result;
+        }
+    }
+}

src/neo/Trie/MPT/MPTDatabase.cs

@@ -0,0 +1,52 @@
+
+using Neo.Persistence;
+using System.Text;
+
+namespace Neo.Trie.MPT
+{
+    public class MPTDatabase
+    {
+        private ISnapshot store;
+
+        public static readonly byte TABLE = 0x4D;
+
+        public static readonly byte[] Prefix = Encoding.ASCII.GetBytes("MPT");
+
+        private byte[] StoreKey(byte[] hash)
+        {
+            return Prefix.Concat(hash);
+        }
+
+        public MPTDatabase(ISnapshot store)
+        {
+            this.store = store;
+        }
+
+        public MPTNode Node(byte[] hash)
+        {
+            var data = store.TryGet(TABLE, StoreKey(hash));
+            var n = MPTNode.Decode(data);
+            return n;
+        }
+
+        public void Delete(byte[] hash)
+        {
+            store.Delete(TABLE, StoreKey(hash));
+        }
+
+        public void Put(MPTNode node)
+        {
+            store.Put(TABLE, StoreKey(node.GetHash()), node.Encode());
+        }
+
+        public void PutRoot(byte[] root)
+        {
+            store.Put(TABLE, StoreKey(Encoding.ASCII.GetBytes("mpt_root")), root);
+        }
+
+        public byte[] GetRoot()
+        {
+            return store.TryGet(TABLE, StoreKey(Encoding.ASCII.GetBytes("mpt_root")));
+        }
+    }
+}

src/neo/Trie/MPT/MPTNode.cs

@@ -0,0 +1,103 @@
+using System.IO;
+using System.Text;
+using Neo.Cryptography;
+using Neo.IO;
+
+namespace Neo.Trie.MPT
+{
+    public enum NodeType
+    {
+        FullNode,
+        ShortNode,
+        HashNode,
+        ValueNode,
+    }
+
+    public class NodeFlag
+    {
+        public byte[] Hash;
+        public bool Dirty;
+
+        public NodeFlag()
+        {
+            Dirty = true;
+        }
+    }
+
+    public abstract class MPTNode : ISerializable
+    {
+        public NodeFlag Flag;
+        protected NodeType nType;
+
+        protected abstract byte[] calHash();
+
+        public virtual byte[] GetHash()
+        {
+            if (!Flag.Dirty) return Flag.Hash;
+            Flag.Hash = calHash();
+            Flag.Dirty = false;
+            return (byte[])Flag.Hash.Clone();
+        }
+
+        public void ResetFlag()
+        {
+            Flag = new NodeFlag();
+        }
+
+        public int Size { get; }
+
+        public MPTNode()
+        {
+            Flag = new NodeFlag();
+        }
+
+        public virtual void Serialize(BinaryWriter writer)
+        {
+            writer.Write((byte)nType);
+        }
+
+        public virtual void Deserialize(BinaryReader reader)
+        {
+
+        }
+
+        public byte[] Encode()
+        {
+            return this.ToArray();
+        }
+
+        public static MPTNode Decode(byte[] data)
+        {
+            var nodeType = (NodeType)data[0];
+            data = data.Skip(1);
+
+            using (MemoryStream ms = new MemoryStream(data, false))
+            using (BinaryReader reader = new BinaryReader(ms, Encoding.UTF8))
+            {
+                switch (nodeType)
+                {
+                    case NodeType.FullNode:
+                        {
+                            var n = new FullNode();
+                            n.Deserialize(reader);
+                            return n;
+                        }
+                    case NodeType.ShortNode:
+                        {
+                            var n = new ShortNode();
+                            n.Deserialize(reader);
+                            return n;
+                        }
+                    case NodeType.ValueNode:
+                        {
+                            var n = new ValueNode();
+                            n.Deserialize(reader);
+                            return n;
+                        }
+                    default:
+                        throw new System.Exception();
+                }
+            }
+        }
+    }
+}

src/neo/Trie/MPT/MPTNode/FullNode.cs

@@ -0,0 +1,58 @@
+using System.IO;
+using Neo.Cryptography;
+using Neo.IO;
+
+namespace Neo.Trie.MPT
+{
+    public class FullNode : MPTNode
+    {
+        public MPTNode[] Children = new MPTNode[17];
+
+        public FullNode()
+        {
+            nType = NodeType.FullNode;
+            for (int i = 0; i < Children.Length; i++)
+            {
+                Children[i] = HashNode.EmptyNode();
+            }
+        }
+
+        protected override byte[] calHash()
+        {
+            var bytes = new byte[0];
+            for (int i = 0; i < Children.Length; i++)
+            {
+                bytes = bytes.Concat(Children[i].GetHash());
+            }
+            return bytes.Sha256();
+        }
+
+        public FullNode Clone()
+        {
+            var cloned = new FullNode();
+            for (int i = 0; i < Children.Length; i++)
+            {
+                cloned.Children[i] = Children[i];
+            }
+            return cloned;
+        }
+
+        public override void Serialize(BinaryWriter writer)
+        {
+            base.Serialize(writer);
+            for (int i = 0; i < Children.Length; i++)
+            {
+                writer.WriteVarBytes(Children[i].GetHash());
+            }
+        }
+
+        public override void Deserialize(BinaryReader reader)
+        {
+            for (int i = 0; i < Children.Length; i++)
+            {
+                var hashNode = new HashNode(reader.ReadVarBytes());
+                Children[i] = hashNode;
+            }
+        }
+    }
+}

src/neo/Trie/MPT/MPTNode/HashNode.cs

@@ -0,0 +1,31 @@
+
+namespace Neo.Trie.MPT
+{
+    public class HashNode : MPTNode
+    {
+        public byte[] Hash;
+
+        public HashNode()
+        {
+            nType = NodeType.HashNode;
+        }
+
+        public HashNode(byte[] hash)
+        {
+            nType = NodeType.HashNode;
+            Hash = (byte[])hash.Clone();
+        }
+
+        protected override byte[] calHash()
+        {
+            return (byte[])Hash.Clone();
+        }
+
+        public static HashNode EmptyNode()
+        {
+            return new HashNode(new byte[] { });
+        }
+
+        public bool IsEmptyNode => Hash.Length == 0;
+    }
+}

src/neo/Trie/MPT/MPTNode/ShortNode.cs

@@ -0,0 +1,48 @@
+using System.IO;
+using Neo.Cryptography;
+using Neo.IO;
+
+namespace Neo.Trie.MPT
+{
+    public class ShortNode : MPTNode
+    {
+        public byte[] Key;
+
+        public MPTNode Next;
+
+        public new int Size => Key.Length + Next.Size;
+
+        protected override byte[] calHash()
+        {
+            return Key.Concat(Next.GetHash()).Sha256();
+        }
+        public ShortNode()
+        {
+            nType = NodeType.ShortNode;
+        }
+
+        public ShortNode Clone()
+        {
+            var cloned = new ShortNode()
+            {
+                Key = (byte[])Key.Clone(),
+                Next = Next,
+            };
+            return cloned;
+        }
+
+        public override void Serialize(BinaryWriter writer)
+        {
+            base.Serialize(writer);
+            writer.WriteVarBytes(Key);
+            writer.WriteVarBytes(Next.GetHash());
+        }
+
+        public override void Deserialize(BinaryReader reader)
+        {
+            Key = reader.ReadVarBytes();
+            var hashNode = new HashNode(reader.ReadVarBytes());
+            Next = hashNode;
+        }
+    }
+}