X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=Novacoin%2FCBlockStore.cs;h=c6361218e6bb0ff4b2809d92c5ecd7aef440d685;hb=514b68fc3103fca11d6d06ddb65ed8d2a14507e1;hp=a9c504cdfd310a048d42043a18c9adabc1e4bd26;hpb=7726cc3ff2ad58160957235de7c08f1e704c8532;p=NovacoinLibrary.git

diff --git a/Novacoin/CBlockStore.cs b/Novacoin/CBlockStore.cs
index a9c504c..c636121 100644
--- a/Novacoin/CBlockStore.cs
+++ b/Novacoin/CBlockStore.cs
@@ -1,4 +1,23 @@
-using System;
+/**
+*  Novacoin classes library
+*  Copyright (C) 2015 Alex D. (balthazar.ad@gmail.com)
+
+*  This program is free software: you can redistribute it and/or modify
+*  it under the terms of the GNU Affero General Public License as
+*  published by the Free Software Foundation, either version 3 of the
+*  License, or (at your option) any later version.
+
+*  This program is distributed in the hope that it will be useful,
+*  but WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*  GNU Affero General Public License for more details.
+
+*  You should have received a copy of the GNU Affero General Public License
+*  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+using System;
 using System.IO;
 using System.Linq;
 using System.Collections.Concurrent;
@@ -9,20 +28,20 @@ using SQLite.Net.Interop;
 using SQLite.Net.Platform.Generic;
 using SQLiteNetExtensions.Attributes;
 using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Text;
 
 namespace Novacoin
 {
-    /// <summary>
-    /// Block headers table
-    /// </summary>
     [Table("BlockStorage")]
-    public class CBlockStoreItem
+    public class CBlockStoreItem : IBlockStorageItem
     {
+        #region IBlockStorageItem
         /// <summary>
         /// Item ID in the database
         /// </summary>
         [PrimaryKey, AutoIncrement]
-        public int ItemID { get; set; }
+        public long ItemID { get; set; }
 
         /// <summary>
         /// PBKDF2+Salsa20 of block hash
@@ -33,62 +52,124 @@ namespace Novacoin
         /// <summary>
         /// Version of block schema
         /// </summary>
+        [Column("nVersion")]
         public uint nVersion { get; set; }
 
         /// <summary>
         /// Previous block hash.
         /// </summary>
+        [Column("prevHash")]
         public byte[] prevHash { get; set; }
 
         /// <summary>
         /// Merkle root hash.
         /// </summary>
+        [Column("merkleRoot")]
         public byte[] merkleRoot { get; set; }
 
         /// <summary>
         /// Block timestamp.
         /// </summary>
+        [Column("nTime")]
         public uint nTime { get; set; }
 
         /// <summary>
         /// Compressed difficulty representation.
         /// </summary>
+        [Column("nBits")]
         public uint nBits { get; set; }
 
         /// <summary>
         /// Nonce counter.
         /// </summary>
+        [Column("nNonce")]
         public uint nNonce { get; set; }
 
         /// <summary>
+        /// Next block hash.
+        /// </summary>
+        [Column("nextHash")]
+        public byte[] nextHash { get; set; }
+
+        /// <summary>
         /// Block type flags
         /// </summary>
+        [Column("BlockTypeFlag")]
         public BlockType BlockTypeFlag { get; set; }
 
         /// <summary>
         /// Stake modifier
         /// </summary>
+        [Column("nStakeModifier")]
         public long nStakeModifier { get; set; }
 
         /// <summary>
-        /// Stake entropy bit
+        /// Proof-of-Stake hash
         /// </summary>
-        public byte nEntropyBit { get; set; }
+        [Column("hashProofOfStake")]
+        public byte[] hashProofOfStake { get; set; }
 
         /// <summary>
-        /// Block height
+        /// Stake generation outpoint.
         /// </summary>
-        public uint nHeight { get; set; }
+        [Column("prevoutStake")]
+        public byte[] prevoutStake { get; set; }
 
         /// <summary>
-        /// Block position in file
+        /// Stake generation time.
         /// </summary>
-        public long nBlockPos { get; set; }
+        [Column("nStakeTime")]
+        public uint nStakeTime { get; set; }
 
         /// <summary>
-        /// Block size in bytes
+        /// Block height, encoded in VarInt format
         /// </summary>
-        public int nBlockSize { get; set; }
+        [Column("Height")]
+        public byte[] Height { get; set; }
+
+        /// <summary>
+        /// Block position in file, encoded in VarInt format
+        /// </summary>
+        [Column("BlockPos")]
+        public byte[] BlockPos { get; set; }
+
+        /// <summary>
+        /// Block size in bytes, encoded in VarInt format
+        /// </summary>
+        [Column("BlockSize")]
+        public byte[] BlockSize { get; set; }
+        #endregion
+
+        /// <summary>
+        /// Accessor and mutator for BlockPos value.
+        /// </summary>
+        [Ignore]
+        public long nBlockPos
+        {
+            get { return (long)VarInt.DecodeVarInt(BlockPos); }
+            set { BlockPos = VarInt.EncodeVarInt(value); }
+        }
+
+        /// <summary>
+        /// Accessor and mutator for BlockSize value.
+        /// </summary>
+        [Ignore]
+        public int nBlockSize
+        {
+            get { return (int)VarInt.DecodeVarInt(BlockSize); }
+            set { BlockSize = VarInt.EncodeVarInt(value); }
+        }
+
+        /// <summary>
+        /// Accessor and mutator for Height value.
+        /// </summary>
+        [Ignore]
+        public uint nHeight
+        {
+            get { return (uint)VarInt.DecodeVarInt(Height); }
+            set { Height = VarInt.EncodeVarInt(value); }
+        }
+
 
         /// <summary>
         /// Fill database item with data from given block header.
@@ -97,8 +178,9 @@ namespace Novacoin
         /// <returns>Header hash</returns>
         public uint256 FillHeader(CBlockHeader header)
         {
-            uint256 _hash;
-            Hash = _hash = header.Hash;
+            uint256 _hash = header.Hash;
+
+            Hash = _hash;
 
             nVersion = header.nVersion;
             prevHash = header.prevHash;
@@ -211,19 +293,60 @@ namespace Novacoin
         /// <summary>
         /// Previous block cursor
         /// </summary>
-        public public CBlockStoreItem prev {
+        [Ignore]
+        public CBlockStoreItem prev {
             get { return CBlockStore.Instance.GetCursor(prevHash); }
         }
 
         /// <summary>
+        /// Next block cursor
+        /// </summary>
+        [Ignore]
+        public CBlockStoreItem next
+        {
+            get
+            {
+                if (nextHash == null)
+                {
+                    return null;
+                }
+
+                return CBlockStore.Instance.GetCursor(nextHash);
+            }
+            set
+            {
+                CBlockStoreItem newCursor = this;
+                newCursor.nextHash = value.Hash;
+
+                CBlockStore.Instance.UpdateCursor(this, ref newCursor);
+            }
+        }
+
+        [Ignore]
+        bool IsInMainChain
+        {
+            get { return (next != null); }
+        }
+
+        /// <summary>
         /// STake modifier generation flag
         /// </summary>
+        [Ignore]
         public bool GeneratedStakeModifier
         {
             get { return (BlockTypeFlag & BlockType.BLOCK_STAKE_MODIFIER) != 0; }
         }
 
         /// <summary>
+        /// Stake entropy bit
+        /// </summary>
+        [Ignore]
+        public uint StakeEntropyBit
+        {
+            get { return ((uint)(BlockTypeFlag & BlockType.BLOCK_STAKE_ENTROPY) >> 1); }
+        }
+
+        /// <summary>
         /// Sets stake modifier and flag.
         /// </summary>
         /// <param name="nModifier">New stake modifier.</param>
@@ -259,20 +382,134 @@ namespace Novacoin
         /// <summary>
         /// Block has no proof-of-stake flag.
         /// </summary>
+        [Ignore]
         public bool IsProofOfWork
         {
-            get { return (BlockTypeFlag & BlockType.BLOCK_PROOF_OF_STAKE) != 0; }
+            get { return (BlockTypeFlag & BlockType.BLOCK_PROOF_OF_STAKE) == 0; }
         }
 
         /// <summary>
         /// Block has proof-of-stake flag set.
         /// </summary>
+        [Ignore]
         public bool IsProofOfStake 
         {
-            get { return (BlockTypeFlag & BlockType.BLOCK_PROOF_OF_STAKE) == 0; }
+            get { return (BlockTypeFlag & BlockType.BLOCK_PROOF_OF_STAKE) != 0; }
+        }
+
+        /// <summary>
+        /// Block trust score.
+        /// </summary>
+        [Ignore]
+        public uint256 nBlockTrust
+        {
+            get
+            {
+                uint256 nTarget = 0;
+                nTarget.Compact = nBits;
+
+                /* Old protocol */
+                if (nTime < NetUtils.nChainChecksSwitchTime)
+                {
+                    return IsProofOfStake ? (new uint256(1) << 256) / (nTarget + 1) : 1;
+                }
+
+                /* New protocol */
+
+                // Calculate work amount for block
+                var nPoWTrust = NetUtils.nPoWBase / (nTarget + 1);
+
+                // Set nPowTrust to 1 if we are checking PoS block or PoW difficulty is too low
+                nPoWTrust = (IsProofOfStake || !nPoWTrust) ? 1 : nPoWTrust;
+
+                // Return nPoWTrust for the first 12 blocks
+                if (prev == null || prev.nHeight < 12)
+                    return nPoWTrust;
+
+                CBlockStoreItem currentIndex = prev;
+
+                if (IsProofOfStake)
+                {
+                    var nNewTrust = (new uint256(1) << 256) / (nTarget + 1);
+
+                    // Return 1/3 of score if parent block is not the PoW block
+                    if (!prev.IsProofOfWork)
+                    {
+                        return nNewTrust / 3;
+                    }
+
+                    int nPoWCount = 0;
+
+                    // Check last 12 blocks type
+                    while (prev.nHeight - currentIndex.nHeight < 12)
+                    {
+                        if (currentIndex.IsProofOfWork)
+                        {
+                            nPoWCount++;
+                        }
+                        currentIndex = currentIndex.prev;
+                    }
+
+                    // Return 1/3 of score if less than 3 PoW blocks found
+                    if (nPoWCount < 3)
+                    {
+                        return nNewTrust / 3;
+                    }
+
+                    return nNewTrust;
+                }
+                else
+                {
+                    var nLastBlockTrust = prev.nChainTrust - prev.prev.nChainTrust;
+
+                    // Return nPoWTrust + 2/3 of previous block score if two parent blocks are not PoS blocks
+                    if (!prev.IsProofOfStake || !prev.prev.IsProofOfStake)
+                    {
+                        return nPoWTrust + (2 * nLastBlockTrust / 3);
+                    }
+
+                    int nPoSCount = 0;
+
+                    // Check last 12 blocks type
+                    while (prev.nHeight - currentIndex.nHeight < 12)
+                    {
+                        if (currentIndex.IsProofOfStake)
+                        {
+                            nPoSCount++;
+                        }
+                        currentIndex = currentIndex.prev;
+                    }
+
+                    // Return nPoWTrust + 2/3 of previous block score if less than 7 PoS blocks found
+                    if (nPoSCount < 7)
+                    {
+                        return nPoWTrust + (2 * nLastBlockTrust / 3);
+                    }
+
+                    nTarget.Compact = prev.nBits;
+
+                    if (!nTarget)
+                    {
+                        return 0;
+                    }
+
+                    var nNewTrust = (new uint256(1) << 256) / (nTarget + 1);
+
+                    // Return nPoWTrust + full trust score for previous block nBits
+                    return nPoWTrust + nNewTrust;
+                }
+            }
         }
 
+        /// <summary>
+        /// Stake modifier checksum.
+        /// </summary>
+        public uint nStakeModifierChecksum;
 
+        /// <summary>
+        /// Chain trust score
+        /// </summary>
+        public uint256 nChainTrust;
     }
 
     /// <summary>
@@ -288,42 +525,62 @@ namespace Novacoin
     /// <summary>
     /// Transaction type.
     /// </summary>
-    public enum TxType
+    public enum TxFlags : byte
     {
         TX_COINBASE,
         TX_COINSTAKE,
         TX_USER
     }
 
-    [Table("TransactionStorage")]
-    public class CTransactionStoreItem
+    /// <summary>
+    /// Output flags.
+    /// </summary>
+    public enum OutputFlags : byte
     {
+        AVAILABLE, // Unspent output
+        SPENT      // Spent output
+    }
+
+    [Table("MerkleNodes")]
+    public class CMerkleNode : IMerkleNode
+    {
+        #region IMerkleNode
         /// <summary>
-        /// Transaction hash
+        /// Node identifier
         /// </summary>
-        [PrimaryKey]
-        public byte[] TransactionHash { get; set; }
+        [PrimaryKey, AutoIncrement]
+        public long nMerkleNodeID { get; set; }
 
         /// <summary>
-        /// Block hash
+        /// Reference to parent block database item.
         /// </summary>
-        [ForeignKey(typeof(CBlockStoreItem), Name = "Hash")]
-        public byte[] BlockHash { get; set; }
+        [ForeignKey(typeof(CBlockStoreItem), Name = "ItemId")]
+        public long nParentBlockID { get; set; }
 
         /// <summary>
         /// Transaction type flag
         /// </summary>
-        public TxType txType { get; set; }
+        [Column("TransactionFlags")]
+        public TxFlags TransactionFlags { get; set; }
+
+        /// <summary>
+        /// Transaction hash
+        /// </summary>
+        [Column("TransactionHash")]
+        public byte[] TransactionHash { get; set; }
 
         /// <summary>
-        /// Tx position in file
+        /// Transaction offset from the beginning of block header, encoded in VarInt format.
         /// </summary>
-        public long nTxPos { get; set; }
+        [Column("TxOffset")]
+        public byte[] TxOffset { get; set; }
 
         /// <summary>
-        /// Transaction size
+        /// Transaction size, encoded in VarInt format.
         /// </summary>
-        public int nTxSize { get; set; }
+        [Column("TxSize")]
+        public byte[] TxSize { get; set; }
+        #endregion
 
         /// <summary>
         /// Read transaction from file.
@@ -331,14 +588,15 @@ namespace Novacoin
         /// <param name="reader">Stream with read access.</param>
         /// <param name="tx">CTransaction reference.</param>
         /// <returns>Result</returns>
-        public bool ReadFromFile(ref Stream reader, out CTransaction tx)
+        public bool ReadFromFile(ref Stream reader, long nBlockPos, out CTransaction tx)
         {
             var buffer = new byte[CTransaction.nMaxTxSize];
+
             tx = null;
 
             try
             {
-                reader.Seek(nTxPos, SeekOrigin.Begin); // Seek to transaction offset
+                reader.Seek(nBlockPos + nTxOffset, SeekOrigin.Begin); // Seek to transaction offset
 
                 if (nTxSize != reader.Read(buffer, 0, nTxSize))
                 {
@@ -360,6 +618,80 @@ namespace Novacoin
                 return false;
             }
         }
+
+        /// <summary>
+        /// Transaction offset accessor
+        /// </summary>
+        [Ignore]
+        public long nTxOffset
+        {
+            get { return (long) VarInt.DecodeVarInt(TxOffset); }
+        }
+
+        /// <summary>
+        /// Transaction size accessor
+        /// </summary>
+        [Ignore]
+        public int nTxSize
+        {
+            get { return (int)VarInt.DecodeVarInt(TxSize); }
+        }
+
+    }
+
+    [Table("Outputs")]
+    public class TxOutItem : ITxOutItem
+    {
+        /// <summary>
+        /// Reference to transaction item.
+        /// </summary>
+        [ForeignKey(typeof(CMerkleNode), Name = "nMerkleNodeID")]
+        public long nMerkleNodeID { get; set; }
+
+        /// <summary>
+        /// Output flags
+        /// </summary>
+        public OutputFlags outputFlags { get; set; }
+
+        /// <summary>
+        /// Output number in VarInt format.
+        /// </summary>
+        public byte[] OutputNumber { get; set; }
+
+        /// <summary>
+        /// Output value in VarInt format.
+        /// </summary>
+        public byte[] OutputValue { get; set; }
+
+        /// <summary>
+        /// Second half of script which contains spending instructions.
+        /// </summary>
+        public byte[] scriptPubKey { get; set; }
+
+        /// <summary>
+        /// Getter for output number.
+        /// </summary>
+        public uint nOut
+        {
+            get { return (uint)VarInt.DecodeVarInt(OutputNumber); }
+        }
+
+        /// <summary>
+        /// Getter for output value.
+        /// </summary>
+        public ulong nValue
+        {
+            get { return VarInt.DecodeVarInt(OutputValue); }
+        }
+
+        /// <summary>
+        /// Getter ans setter for IsSpent flag.
+        /// </summary>
+        public bool IsSpent
+        {
+            get { return (outputFlags & OutputFlags.SPENT) != 0; }
+            set { outputFlags |= value ? OutputFlags.SPENT : OutputFlags.AVAILABLE; }
+        }
     }
 
     public class CBlockStore : IDisposable
@@ -386,6 +718,8 @@ namespace Novacoin
 
         /// <summary>
         /// Map of block tree nodes.
+        /// 
+        /// blockHash => CBlockStoreItem
         /// </summary>
         private ConcurrentDictionary<uint256, CBlockStoreItem> blockMap = new ConcurrentDictionary<uint256, CBlockStoreItem>();
 
@@ -396,14 +730,48 @@ namespace Novacoin
         private ConcurrentDictionary<uint256, CBlock> orphanMapByPrev = new ConcurrentDictionary<uint256, CBlock>();
 
         /// <summary>
-        /// Map of unspent items.
+        /// Unconfirmed transactions.
+        /// 
+        /// TxID => Transaction
+        /// </summary>
+        private ConcurrentDictionary<uint256, CTransaction> mapUnconfirmedTx = new ConcurrentDictionary<uint256, CTransaction>();
+
+        /// <summary>
+        /// Map of the proof-of-stake hashes. This is necessary for stake duplication checks.
+        /// </summary>
+        private ConcurrentDictionary<uint256, uint256> mapProofOfStake = new ConcurrentDictionary<uint256, uint256>();
+
+
+        private ConcurrentDictionary<COutPoint, uint> mapStakeSeen = new ConcurrentDictionary<COutPoint, uint>();
+        private ConcurrentDictionary<COutPoint, uint> mapStakeSeenOrphan = new ConcurrentDictionary<COutPoint, uint>();
+
+        /// <summary>
+        /// Trust score for the longest chain.
+        /// </summary>
+        private uint256 nBestChainTrust = 0;
+
+        /// <summary>
+        /// Top block of the best chain.
         /// </summary>
-        private ConcurrentDictionary<uint256, CTransactionStoreItem> txMap = new ConcurrentDictionary<uint256, CTransactionStoreItem>();
+        private uint256 nHashBestChain = 0;
 
-        public static CBlockStore Instance;
+        /// <summary>
+        /// Cursor which is pointing us to the end of best chain.
+        /// </summary>
+        private CBlockStoreItem bestBlockCursor = null;
 
         /// <summary>
-        /// Block file stream with read access
+        /// Cursor which is always pointing us to genesis block.
+        /// </summary>
+        private CBlockStoreItem genesisBlockCursor = null;
+
+        /// <summary>
+        /// Current and the only instance of block storage manager. Should be a property with private setter though it's enough for the beginning.
+        /// </summary>
+        public static CBlockStore Instance = null;
+
+        /// <summary>
+        /// Block file stream with read/write access
         /// </summary>
         private Stream fStreamReadWrite;
 
@@ -422,13 +790,16 @@ namespace Novacoin
 
             fStreamReadWrite = File.Open(strBlockFile, FileMode.OpenOrCreate, FileAccess.ReadWrite);
 
+            Instance = this;
+
             if (firstInit)
             {
                 lock (LockObj)
                 {
                     // Create tables
                     dbConn.CreateTable<CBlockStoreItem>(CreateFlags.AutoIncPK);
-                    dbConn.CreateTable<CTransactionStoreItem>(CreateFlags.ImplicitPK);
+                    dbConn.CreateTable<CMerkleNode>(CreateFlags.AutoIncPK);
+                    dbConn.CreateTable<TxOutItem>(CreateFlags.ImplicitPK);
 
                     var genesisBlock = new CBlock(
                         Interop.HexToArray(
@@ -476,20 +847,25 @@ namespace Novacoin
                 foreach (var item in blockTreeItems)
                 {
                     blockMap.TryAdd(item.Hash, item);
+
+                    if (item.IsProofOfStake)
+                    {
+                        // build mapStakeSeen
+                        mapStakeSeen.TryAdd(item.prevoutStake, item.nStakeTime);
+                    }
                 }
             }
-
-            Instance = this;
         }
 
-        public bool GetTransaction(uint256 TxID, ref CTransaction tx)
+        public bool GetTxOutCursor(COutPoint outpoint, ref TxOutItem txOutCursor)
         {
-            var reader = new BinaryReader(fStreamReadWrite).BaseStream;
-            var QueryTx = dbConn.Query<CTransactionStoreItem>("select * from [TransactionStorage] where [TransactionHash] = ?", (byte[])TxID);
+            var queryResults = dbConn.Query<TxOutItem>("select o.* from [Outputs] o left join [MerkleNodes] m on (m.nMerkleNodeID = o.nMerkleNodeID) where m.[TransactionHash] = ?", (byte[])outpoint.hash);
 
-            if (QueryTx.Count == 1)
+            if (queryResults.Count == 1)
             {
-                return QueryTx[0].ReadFromFile(ref reader, out tx);
+                txOutCursor = queryResults[0];
+
+                return true;
             }
 
             // Tx not found
@@ -497,6 +873,47 @@ namespace Novacoin
             return false;
         }
 
+        public bool FetchInputs(ref CTransaction tx, ref Dictionary<uint256, TxOutItem> queued, out TxOutItem[] inputs, bool IsBlock, out bool Invalid)
+        {
+            Invalid = true;
+            inputs = null;
+
+            StringBuilder queryBuilder = new StringBuilder();
+            
+            queryBuilder.Append("select o.* from [Outputs] o left join [MerkleNodes] m on (m.[nMerkleNodeID] = o.[nMerkleNodeID]) where ");
+
+            for (var i = 0; i < tx.vin.Length; i++)
+            {
+                queryBuilder.AppendFormat(" {0} (m.[TransactionHash] = x'{1}' and o.[OutputNumber] = x'{2}')", 
+                    (i > 0 ? "or" : string.Empty), Interop.ToHex(tx.vin[i].prevout.hash), 
+                    Interop.ToHex(VarInt.EncodeVarInt(tx.vin[i].prevout.n)
+                ));
+            }
+
+            var queryResults = dbConn.Query<TxOutItem>(queryBuilder.ToString());
+
+            if (queryResults.Count < tx.vin.Length)
+            {
+                // It seems than some transactions are being spent in the same block.
+
+                if (IsBlock)
+                {
+                    
+                }
+                else
+                {
+                    // TODO: use mapUnconfirmed
+
+                    return false;
+                }
+            }
+
+            inputs = queryResults.ToArray();
+            Invalid = false;
+
+            return true;
+        }
+
         private bool AddItemToIndex(ref CBlockStoreItem itemTemplate, ref CBlock block)
         {
             var writer = new BinaryWriter(fStreamReadWrite).BaseStream;
@@ -508,55 +925,193 @@ namespace Novacoin
                 return false;
             }
 
-            // TODO: compute chain trust, set stake entropy bit, record proof-of-stake hash value
+            // Compute chain trust score
+            itemTemplate.nChainTrust = (itemTemplate.prev != null ? itemTemplate.prev.nChainTrust : 0) + itemTemplate.nBlockTrust;
+
+            if (!itemTemplate.SetStakeEntropyBit(Entropy.GetStakeEntropyBit(itemTemplate.nHeight, blockHash)))
+            {
+                return false; // SetStakeEntropyBit() failed
+            }
+
+            // Save proof-of-stake hash value
+            if (itemTemplate.IsProofOfStake)
+            {
+                uint256 hashProofOfStake;
+                if (!GetProofOfStakeHash(blockHash, out hashProofOfStake))
+                {
+                    return false;  // hashProofOfStake not found 
+                }
+                itemTemplate.hashProofOfStake = hashProofOfStake;
+            }
 
-            // TODO: compute stake modifier
+            // compute stake modifier
+            long nStakeModifier = 0;
+            bool fGeneratedStakeModifier = false;
+            if (!StakeModifier.ComputeNextStakeModifier(itemTemplate, ref nStakeModifier, ref fGeneratedStakeModifier))
+            {
+                return false;  // ComputeNextStakeModifier() failed
+            }
+
+            itemTemplate.SetStakeModifier(nStakeModifier, fGeneratedStakeModifier);
+            itemTemplate.nStakeModifierChecksum = StakeModifier.GetStakeModifierChecksum(itemTemplate);
+
+            // TODO: verify stake modifier checkpoints
 
             // Add to index
-            itemTemplate.BlockTypeFlag = block.IsProofOfStake ? BlockType.PROOF_OF_STAKE : BlockType.PROOF_OF_WORK;
+            if (block.IsProofOfStake)
+            {
+                itemTemplate.SetProofOfStake();
+
+                itemTemplate.prevoutStake = block.vtx[1].vin[0].prevout;
+                itemTemplate.nStakeTime = block.vtx[1].nTime;
+            }
 
             if (!itemTemplate.WriteToFile(ref writer, ref block))
             {
                 return false;
             }
 
-            dbConn.Insert(itemTemplate);
+            if (dbConn.Insert(itemTemplate) == 0 || !blockMap.TryAdd(blockHash, itemTemplate))
+            {
+                return false;
+            }
 
-            // We have no SetBestChain and ConnectBlock/Disconnect block yet, so adding these transactions manually.
-            for (int i = 0; i < block.vtx.Length; i++)
+            if (itemTemplate.nChainTrust > nBestChainTrust)
             {
-                // Handle trasactions
+                // New best chain
 
-                if (!block.vtx[i].VerifyScripts())
+                // TODO: SetBestChain implementation
+
+                /*
+                if (!SetBestChain(ref itemTemplate))
                 {
-                    return false;
+                    return false; // SetBestChain failed.
                 }
+                */
+            }
 
-                var nTxOffset = itemTemplate.nBlockPos + block.GetTxOffset(i);
-                TxType txnType = TxType.TX_USER;
+            return true;
+        }
 
-                if (block.vtx[i].IsCoinBase)
+        private bool SetBestChain(ref CBlockStoreItem cursor)
+        {
+            dbConn.BeginTransaction();
+
+            uint256 hashBlock = cursor.Hash;
+
+            if (genesisBlockCursor == null && hashBlock == NetUtils.nHashGenesisBlock)
+            {
+                genesisBlockCursor = cursor;
+            }
+            else if (nHashBestChain == (uint256)cursor.prevHash)
+            {
+                if (!SetBestChainInner(cursor))
                 {
-                    txnType = TxType.TX_COINBASE;
+                    return false;
                 }
-                else if (block.vtx[i].IsCoinStake)
+            }
+            else
+            {
+                // the first block in the new chain that will cause it to become the new best chain
+                CBlockStoreItem cursorIntermediate = cursor;
+
+                // list of blocks that need to be connected afterwards
+                List<CBlockStoreItem> secondary = new List<CBlockStoreItem>();
+
+                // Reorganize is costly in terms of db load, as it works in a single db transaction.
+                // Try to limit how much needs to be done inside
+                while (cursorIntermediate.prev != null && cursorIntermediate.prev.nChainTrust > bestBlockCursor.nChainTrust)
                 {
-                    txnType = TxType.TX_COINSTAKE;
+                    secondary.Add(cursorIntermediate);
+                    cursorIntermediate = cursorIntermediate.prev;
                 }
 
-                var NewTxItem = new CTransactionStoreItem()
+                // Switch to new best branch
+                if (!Reorganize(cursorIntermediate))
                 {
-                    TransactionHash = block.vtx[i].Hash,
-                    BlockHash = blockHash,
-                    nTxPos = nTxOffset,
-                    nTxSize = block.vtx[i].Size,
-                    txType = txnType
-                };
+                    dbConn.Rollback();
+                    InvalidChainFound(cursor);
+                    return false; // reorganize failed
+                }
+
+
+            }
+
+
+            throw new NotImplementedException();
+        }
+
+        private void InvalidChainFound(CBlockStoreItem cursor)
+        {
+            throw new NotImplementedException();
+        }
+
+        private bool Reorganize(CBlockStoreItem cursorIntermediate)
+        {
+            throw new NotImplementedException();
+        }
 
-                dbConn.Insert(NewTxItem);
+        private bool SetBestChainInner(CBlockStoreItem cursor)
+        {
+            uint256 hash = cursor.Hash;
+            CBlock block;
+
+            // Adding to current best branch
+            if (!ConnectBlock(cursor, false, out block) || !WriteHashBestChain(hash))
+            {
+                dbConn.Rollback();
+                InvalidChainFound(cursor);
+                return false;
             }
 
-            return blockMap.TryAdd(blockHash, itemTemplate);
+            // Add to current best branch
+            cursor.prev.next = cursor;
+
+            dbConn.Commit();
+
+            // Delete redundant memory transactions
+            foreach (var tx in block.vtx)
+            {
+                CTransaction dummy;
+                mapUnconfirmedTx.TryRemove(tx.Hash, out dummy);
+            }
+
+            return true;
+        }
+
+        private bool ConnectBlock(CBlockStoreItem cursor, bool fJustCheck, out CBlock block)
+        {
+            var reader = new BinaryReader(fStreamReadWrite).BaseStream;
+            if (cursor.ReadFromFile(ref reader, out block))
+            {
+                return false; // Unable to read block from file.
+            }
+
+            // Check it again in case a previous version let a bad block in, but skip BlockSig checking
+            if (!block.CheckBlock(!fJustCheck, !fJustCheck, false))
+            {
+                return false; // Invalid block found.
+            }
+
+            // TODO: the remaining stuff lol :D
+
+            throw new NotImplementedException();
+        }
+
+        private bool WriteHashBestChain(uint256 hash)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Try to find proof-of-stake hash in the map.
+        /// </summary>
+        /// <param name="blockHash">Block hash</param>
+        /// <param name="hashProofOfStake">Proof-of-stake hash</param>
+        /// <returns>Proof-of-Stake hash value</returns>
+        private bool GetProofOfStakeHash(uint256 blockHash, out uint256 hashProofOfStake)
+        {
+            return mapProofOfStake.TryGetValue(blockHash, out hashProofOfStake);
         }
 
         public bool AcceptBlock(ref CBlock block)
@@ -603,7 +1158,6 @@ namespace Novacoin
             var itemTemplate = new CBlockStoreItem()
             {
                 nHeight = nHeight,
-                nEntropyBit = Entropy.GetStakeEntropyBit(nHeight, nHash)
             };
 
             itemTemplate.FillHeader(block.header);
@@ -616,7 +1170,7 @@ namespace Novacoin
             return true;
         }
 
-        public bool GetBlock(uint256 blockHash, ref CBlock block)
+        public bool GetBlock(uint256 blockHash, ref CBlock block, ref long nBlockPos)
         {
             var reader = new BinaryReader(fStreamReadWrite).BaseStream;
 
@@ -624,6 +1178,7 @@ namespace Novacoin
 
             if (QueryBlock.Count == 1)
             {
+                nBlockPos = QueryBlock[0].nBlockPos;
                 return QueryBlock[0].ReadFromFile(ref reader, out block);
             }
 
@@ -632,6 +1187,47 @@ namespace Novacoin
             return false;
         }
 
+
+        /// <summary>
+        /// Interface for join
+        /// </summary>
+        interface IBlockJoinMerkle : IBlockStorageItem, IMerkleNode
+        {
+        }
+
+        /// <summary>
+        /// Get block and transaction by transaction hash.
+        /// </summary>
+        /// <param name="TxID">Transaction hash</param>
+        /// <param name="block">Block reference</param>
+        /// <param name="tx">Transaction reference</param>
+        /// <param name="nBlockPos">Block position reference</param>
+        /// <param name="nTxPos">Transaction position reference</param>
+        /// <returns>Result of operation</returns>
+        public bool GetBlockByTransactionID(uint256 TxID, ref CBlock block, ref CTransaction tx, ref long nBlockPos, ref long nTxPos)
+        {
+            var queryResult = dbConn.Query<IBlockJoinMerkle>("select *,  from [BlockStorage] b left join [MerkleNodes] m on (b.[ItemID] = m.[nParentBlockID]) where m.[TransactionHash] = ?", (byte[])TxID);
+
+            if (queryResult.Count == 1)
+            {
+                CBlockStoreItem blockCursor = (CBlockStoreItem) queryResult[0];
+                CMerkleNode txCursor = (CMerkleNode)queryResult[0];
+
+                var reader = new BinaryReader(fStreamReadWrite).BaseStream;
+
+                if (!txCursor.ReadFromFile(ref reader, blockCursor.nBlockPos, out tx))
+                {
+                    return false; // Unable to read transaction
+                }
+
+                return blockCursor.ReadFromFile(ref reader, out block);
+            }
+
+            // Tx not found
+
+            return false;
+        }
+
         /// <summary>
         /// Get block cursor from map.
         /// </summary>
@@ -657,6 +1253,8 @@ namespace Novacoin
 
             if (QueryBlockCursor.Count == 1)
             {
+                blockMap.TryAdd(blockHash, QueryBlockCursor[0]);
+
                 return QueryBlockCursor[0];
             }
 
@@ -664,6 +1262,22 @@ namespace Novacoin
             return null;
         }
 
+        /// <summary>
+        /// Update cursor in memory and on disk.
+        /// </summary>
+        /// <param name="originalItem">Original cursor</param>
+        /// <param name="newItem">New cursor</param>
+        /// <returns></returns>
+        public bool UpdateCursor(CBlockStoreItem originalItem, ref CBlockStoreItem newItem)
+        {
+            if (blockMap.TryUpdate(originalItem.Hash, newItem, originalItem))
+            {
+                return dbConn.Update(newItem) != 0;
+            }
+
+            return false;
+        }
+
         public bool ProcessBlock(ref CBlock block)
         {
             var blockHash = block.header.Hash;
@@ -690,13 +1304,25 @@ namespace Novacoin
 
             if (block.IsProofOfStake)
             {
-                if (!block.SignatureOK || !block.vtx[1].VerifyScripts())
+                if (!block.SignatureOK)
                 {
                     // Proof-of-Stake signature validation failure.
                     return false;
                 }
 
                 // TODO: proof-of-stake validation
+
+                uint256 hashProofOfStake = 0, targetProofOfStake = 0;
+                if (!StakeModifier.CheckProofOfStake(block.vtx[1], block.header.nBits, ref hashProofOfStake, ref targetProofOfStake))
+                {
+                    return false; // do not error here as we expect this during initial block download
+                }
+                if (!mapProofOfStake.ContainsKey(blockHash)) 
+                {
+                    // add to mapProofOfStake
+                    mapProofOfStake.TryAdd(blockHash, hashProofOfStake);
+                }
+
             }
 
             // TODO: difficulty verification