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

diff --git a/Novacoin/CBlockStore.cs b/Novacoin/CBlockStore.cs
index 935a4ab..c636121 100644
--- a/Novacoin/CBlockStore.cs
+++ b/Novacoin/CBlockStore.cs
@@ -28,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
@@ -52,77 +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 modifier checksum.
+        /// Proof-of-Stake hash
         /// </summary>
-        public uint nStakeModifierChecksum { get; set; }
+        [Column("hashProofOfStake")]
+        public byte[] hashProofOfStake { get; set; }
 
         /// <summary>
-        /// Chain trust score
+        /// Stake generation outpoint.
         /// </summary>
-        public byte[] ChainTrust { get; set; }
+        [Column("prevoutStake")]
+        public byte[] prevoutStake { get; set; }
 
         /// <summary>
-        /// Proof-of-Stake hash
+        /// Stake generation time.
         /// </summary>
-        public byte[] hashProofOfStake { get; set; }
+        [Column("nStakeTime")]
+        public uint nStakeTime { get; set; }
 
         /// <summary>
-        /// Block height
+        /// Block height, encoded in VarInt format
         /// </summary>
-        public uint nHeight { get; set; }
+        [Column("Height")]
+        public byte[] Height { get; set; }
 
         /// <summary>
-        /// Block position in file
+        /// Block position in file, encoded in VarInt format
         /// </summary>
-        public long nBlockPos { get; set; }
+        [Column("BlockPos")]
+        public byte[] BlockPos { get; set; }
 
         /// <summary>
-        /// Block size in bytes
+        /// Block size in bytes, encoded in VarInt format
         /// </summary>
-        public int nBlockSize { get; set; }
+        [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.
@@ -131,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;
@@ -256,7 +304,22 @@ namespace Novacoin
         [Ignore]
         public CBlockStoreItem next
         {
-            get { return CBlockStore.Instance.GetCursor(nextHash); }
+            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]
@@ -335,25 +398,6 @@ namespace Novacoin
         }
 
         /// <summary>
-        /// Chain trust score.
-        /// </summary>
-        [Ignore]
-        public uint256 nChainTrust {
-            get
-            {
-                if (ChainTrust.Length != 32)
-                {
-                    byte[] tmp = ChainTrust;
-                    Array.Resize(ref tmp, 32);
-                    ChainTrust = tmp;
-                }
-
-                return ChainTrust;
-            }
-            set { ChainTrust = Interop.TrimArray(value); }
-        }
-
-        /// <summary>
         /// Block trust score.
         /// </summary>
         [Ignore]
@@ -457,6 +501,15 @@ namespace Novacoin
             }
         }
 
+        /// <summary>
+        /// Stake modifier checksum.
+        /// </summary>
+        public uint nStakeModifierChecksum;
+
+        /// <summary>
+        /// Chain trust score
+        /// </summary>
+        public uint256 nChainTrust;
     }
 
     /// <summary>
@@ -472,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.
@@ -515,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))
                 {
@@ -544,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
@@ -570,6 +718,8 @@ namespace Novacoin
 
         /// <summary>
         /// Map of block tree nodes.
+        /// 
+        /// blockHash => CBlockStoreItem
         /// </summary>
         private ConcurrentDictionary<uint256, CBlockStoreItem> blockMap = new ConcurrentDictionary<uint256, CBlockStoreItem>();
 
@@ -580,16 +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, CTransactionStoreItem> txMap = new ConcurrentDictionary<uint256, CTransactionStoreItem>();
+        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>();
 
-        public static CBlockStore Instance;
+
+        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 uint256 nHashBestChain = 0;
+
+        /// <summary>
+        /// Cursor which is pointing us to the end of best chain.
+        /// </summary>
+        private CBlockStoreItem bestBlockCursor = null;
+
+        /// <summary>
+        /// 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 access
+        /// Block file stream with read/write access
         /// </summary>
         private Stream fStreamReadWrite;
 
@@ -616,7 +798,8 @@ namespace Novacoin
                 {
                     // 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(
@@ -664,18 +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);
+                    }
                 }
             }
         }
 
-        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
@@ -683,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;
@@ -706,16 +937,14 @@ namespace Novacoin
             if (itemTemplate.IsProofOfStake)
             {
                 uint256 hashProofOfStake;
-                if (!CBlockStore.Instance.GetProofOfStakeHash(blockHash, out hashProofOfStake))
+                if (!GetProofOfStakeHash(blockHash, out hashProofOfStake))
                 {
                     return false;  // hashProofOfStake not found 
                 }
                 itemTemplate.hashProofOfStake = hashProofOfStake;
             }
 
-            // TODO: compute stake modifier
-
-            // ppcoin: compute stake modifier
+            // compute stake modifier
             long nStakeModifier = 0;
             bool fGeneratedStakeModifier = false;
             if (!StakeModifier.ComputeNextStakeModifier(itemTemplate, ref nStakeModifier, ref fGeneratedStakeModifier))
@@ -732,6 +961,9 @@ namespace Novacoin
             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))
@@ -739,43 +971,136 @@ namespace Novacoin
                 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
+
+                // TODO: SetBestChain implementation
 
-                if (!block.vtx[i].VerifyScripts())
+                /*
+                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.Insert(NewTxItem);
+                    dbConn.Rollback();
+                    InvalidChainFound(cursor);
+                    return false; // reorganize failed
+                }
+
+
             }
 
-            return blockMap.TryAdd(blockHash, itemTemplate);
+
+            throw new NotImplementedException();
+        }
+
+        private void InvalidChainFound(CBlockStoreItem cursor)
+        {
+            throw new NotImplementedException();
+        }
+
+        private bool Reorganize(CBlockStoreItem cursorIntermediate)
+        {
+            throw new NotImplementedException();
+        }
+
+        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;
+            }
+
+            // 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>
@@ -862,14 +1187,40 @@ namespace Novacoin
             return false;
         }
 
-        public bool GetByTransactionID(uint256 TxID, ref CBlock block, ref CTransaction tx, ref long nBlockPos, ref long nTxPos)
+
+        /// <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 QueryTx = dbConn.Query<CTransactionStoreItem>("select * from [TransactionStorage] where [TransactionHash] = ?", (byte[])TxID);
+            var queryResult = dbConn.Query<IBlockJoinMerkle>("select *,  from [BlockStorage] b left join [MerkleNodes] m on (b.[ItemID] = m.[nParentBlockID]) where m.[TransactionHash] = ?", (byte[])TxID);
 
-            if (QueryTx.Count == 1)
+            if (queryResult.Count == 1)
             {
-                nTxPos = QueryTx[0].nTxPos;
-                return GetBlock(QueryTx[0].BlockHash, ref block, ref nBlockPos);
+                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
@@ -902,6 +1253,8 @@ namespace Novacoin
 
             if (QueryBlockCursor.Count == 1)
             {
+                blockMap.TryAdd(blockHash, QueryBlockCursor[0]);
+
                 return QueryBlockCursor[0];
             }
 
@@ -909,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;
@@ -935,7 +1304,7 @@ namespace Novacoin
 
             if (block.IsProofOfStake)
             {
-                if (!block.SignatureOK || !block.vtx[1].VerifyScripts())
+                if (!block.SignatureOK)
                 {
                     // Proof-of-Stake signature validation failure.
                     return false;