X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=Novacoin%2FCBlockStore.cs;h=6b03f083979e2b6e3fea2f4fa71767967944179f;hb=1e2160be4bf5122f8bbea1c493df9a26be91e4cf;hp=94fc2b67662143d9ae4db9f31ed2190fe2bbf9a5;hpb=eb39142ad873e102405ceffb5ec837b510da9096;p=NovacoinLibrary.git diff --git a/Novacoin/CBlockStore.cs b/Novacoin/CBlockStore.cs index 94fc2b6..6b03f08 100644 --- a/Novacoin/CBlockStore.cs +++ b/Novacoin/CBlockStore.cs @@ -1,733 +1,1037 @@ -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 . +*/ + + +using System; using System.IO; -using System.Linq; using System.Collections.Concurrent; using SQLite.Net; -using SQLite.Net.Attributes; using SQLite.Net.Interop; using SQLite.Net.Platform.Generic; -using SQLiteNetExtensions.Attributes; using System.Collections.Generic; +using System.Text; +using System.Diagnostics.Contracts; +using System.Linq; namespace Novacoin { - /// - /// Block headers table - /// - [Table("BlockStorage")] - public class CBlockStoreItem + public class CBlockStore : IDisposable { - /// - /// Item ID in the database - /// - [PrimaryKey, AutoIncrement] - public int ItemID { get; set; } + public const uint nMagicNumber = 0xe5e9e8e4; - /// - /// PBKDF2+Salsa20 of block hash - /// - [Unique] - public byte[] Hash { get; set; } + private bool disposed = false; + private object LockObj = new object(); /// - /// Version of block schema + /// SQLite connection object. /// - public uint nVersion { get; set; } + private SQLiteConnection dbConn; /// - /// Previous block hash. + /// Current SQLite platform /// - public byte[] prevHash { get; set; } + private ISQLitePlatform dbPlatform; /// - /// Merkle root hash. + /// Block file. /// - public byte[] merkleRoot { get; set; } + private string strBlockFile; /// - /// Block timestamp. + /// Index database file. /// - public uint nTime { get; set; } + private string strDbFile; /// - /// Compressed difficulty representation. + /// Map of block tree nodes. + /// + /// blockHash => CBlockStoreItem /// - public uint nBits { get; set; } + private ConcurrentDictionary blockMap = new ConcurrentDictionary(); /// - /// Nonce counter. + /// Orphaned blocks map. /// - public uint nNonce { get; set; } + private ConcurrentDictionary orphanMap = new ConcurrentDictionary(); + private ConcurrentDictionary orphanMapByPrev = new ConcurrentDictionary(); /// - /// Next block hash. + /// Unconfirmed transactions. + /// + /// TxID => Transaction /// - public byte[] nextHash { get; set; } + private ConcurrentDictionary mapUnconfirmedTx = new ConcurrentDictionary(); /// - /// Block type flags + /// Map of the proof-of-stake hashes. This is necessary for stake duplication checks. /// - public BlockType BlockTypeFlag { get; set; } + private ConcurrentDictionary mapProofOfStake = new ConcurrentDictionary(); + + + private ConcurrentDictionary mapStakeSeen = new ConcurrentDictionary(); + private ConcurrentDictionary mapStakeSeenOrphan = new ConcurrentDictionary(); - /// - /// Stake modifier - /// - public long nStakeModifier { get; set; } /// - /// Chain trust score + /// Copy of chain state object. /// - public byte[] ChainTrust { get; set; } + private ChainState ChainParams; /// - /// Proof-of-Stake hash + /// Cursor which is pointing us to the end of best chain. /// - public byte[] hashProofOfStake { get; set; } + private CBlockStoreItem bestBlockCursor = null; /// - /// Block height + /// Cursor which is always pointing us to genesis block. /// - public uint nHeight { get; set; } + private CBlockStoreItem genesisBlockCursor = null; /// - /// Block position in file + /// Current and the only instance of block storage manager. Should be a property with private setter though it's enough for the beginning. /// - public long nBlockPos { get; set; } + public static CBlockStore Instance = null; /// - /// Block size in bytes + /// Block file stream with read/write access /// - public int nBlockSize { get; set; } + private Stream fStreamReadWrite; + private uint nTimeBestReceived; + private int nTransactionsUpdated; /// - /// Fill database item with data from given block header. + /// Init the block storage manager. /// - /// Block header - /// Header hash - public uint256 FillHeader(CBlockHeader header) + /// Path to index database + /// Path to block file + public CBlockStore(string IndexDB = "blockstore.dat", string BlockFile = "blk0001.dat") { - uint256 _hash; - Hash = _hash = header.Hash; + strDbFile = IndexDB; + strBlockFile = BlockFile; - nVersion = header.nVersion; - prevHash = header.prevHash; - merkleRoot = header.merkleRoot; - nTime = header.nTime; - nBits = header.nBits; - nNonce = header.nNonce; + bool firstInit = !File.Exists(strDbFile); + dbPlatform = new SQLitePlatformGeneric(); + dbConn = new SQLiteConnection(dbPlatform, strDbFile); - return _hash; - } + fStreamReadWrite = File.Open(strBlockFile, FileMode.OpenOrCreate, FileAccess.ReadWrite); - /// - /// Reconstruct block header from item data. - /// - public CBlockHeader BlockHeader - { - get + Instance = this; + + if (firstInit) { - CBlockHeader header = new CBlockHeader(); + lock (LockObj) + { + // Create tables + dbConn.CreateTable(CreateFlags.AutoIncPK); + dbConn.CreateTable(CreateFlags.AutoIncPK); + dbConn.CreateTable(CreateFlags.ImplicitPK); + dbConn.CreateTable(CreateFlags.AutoIncPK); - header.nVersion = nVersion; - header.prevHash = prevHash; - header.merkleRoot = merkleRoot; - header.nTime = nTime; - header.nBits = nBits; - header.nNonce = nNonce; + ChainParams = new ChainState() + { + nBestChainTrust = 0, + nBestHeight = 0, + nHashBestChain = 0 + }; - return header; - } - } + dbConn.Insert(ChainParams); - /// - /// Read block from file. - /// - /// Stream with read access. - /// CBlock reference. - /// Result - public bool ReadFromFile(ref Stream reader, out CBlock block) - { - var buffer = new byte[nBlockSize]; - block = null; + var genesisBlock = new CBlock( + Interop.HexToArray( + "01000000" + // nVersion=1 + "0000000000000000000000000000000000000000000000000000000000000000" + // prevhash is zero + "7b0502ad2f9f675528183f83d6385794fbcaa914e6d385c6cb1d866a3b3bb34c" + // merkle root + "398e1151" + // nTime=1360105017 + "ffff0f1e" + // nBits=0x1e0fffff + "d3091800" + // nNonce=1575379 + "01" + // nTxCount=1 + "01000000" + // nVersion=1 + "398e1151" + // nTime=1360105017 + "01" + // nInputs=1 + "0000000000000000000000000000000000000000000000000000000000000000" + // input txid is zero + "ffffffff" + // n=uint.maxValue + "4d" + // scriptSigLen=77 + "04ffff001d020f274468747470733a2f2f626974636f696e74616c6b2e6f72672f696e6465782e7068703f746f7069633d3133343137392e6d736731353032313936236d736731353032313936" + // scriptSig + "ffffffff" + // nSequence=uint.maxValue + "01" + // nOutputs=1 + "0000000000000000" + // nValue=0 + "00" + // scriptPubkeyLen=0 + "00000000" + // nLockTime=0 + "00" // sigLen=0 + )); - try + // Write block to file. + var itemTemplate = new CBlockStoreItem() + { + nHeight = 0 + }; + + itemTemplate.FillHeader(genesisBlock.header); + + if (!AddItemToIndex(ref itemTemplate, ref genesisBlock)) + { + throw new Exception("Unable to write genesis block"); + } + } + } + else { - reader.Seek(nBlockPos, SeekOrigin.Begin); + var blockTreeItems = dbConn.Query("select * from [BlockStorage] order by [ItemId] asc"); - if (nBlockSize != reader.Read(buffer, 0, nBlockSize)) + // Init list of block items + foreach (var item in blockTreeItems) { - return false; + blockMap.TryAdd(item.Hash, item); + + if (item.IsProofOfStake) + { + // build mapStakeSeen + mapStakeSeen.TryAdd(item.prevoutStake, item.nStakeTime); + } } - block = new CBlock(buffer); + // Load data about the top node. + ChainParams = dbConn.Table().First(); - return true; - } - catch (IOException) - { - // I/O error - return false; - } - catch (BlockException) - { - // Constructor exception - return false; + genesisBlockCursor = dbConn.Query("select * from [BlockStorage] where [Hash] = ?", (byte[])NetInfo.nHashGenesisBlock).First(); + bestBlockCursor = dbConn.Query("select * from [BlockStorage] where [Hash] = ?", ChainParams.HashBestChain).First(); } } - /// - /// Writes given block to file and prepares cursor object for insertion into the database. - /// - /// Stream with write access. - /// CBlock reference. - /// Result - public bool WriteToFile(ref Stream writer, ref CBlock block) + public bool GetTxOutCursor(COutPoint outpoint, out TxOutItem txOutCursor) { - try + var queryResults = dbConn.Query("select o.* from [Outputs] o left join [MerkleNodes] m on (m.nMerkleNodeID = o.nMerkleNodeID) where m.[TransactionHash] = ?", (byte[])outpoint.hash); + + if (queryResults.Count == 1) { - byte[] blockBytes = block; + txOutCursor = queryResults[0]; - var magicBytes = BitConverter.GetBytes(CBlockStore.nMagicNumber); - var blkLenBytes = BitConverter.GetBytes(blockBytes.Length); + return true; + } - // Seek to the end and then append magic bytes there. - writer.Seek(0, SeekOrigin.End); - writer.Write(magicBytes, 0, magicBytes.Length); - writer.Write(blkLenBytes, 0, blkLenBytes.Length); + // Tx not found - // Save block size and current position in the block cursor fields. - nBlockPos = writer.Position; - nBlockSize = blockBytes.Length; + txOutCursor = null; - // Write block and flush the stream. - writer.Write(blockBytes, 0, blockBytes.Length); - writer.Flush(); + return false; + } + + public bool FetchInputs(ref CTransaction tx, ref Dictionary queued, ref Dictionary inputs, bool IsBlock, out bool Invalid) + { + Invalid = false; + if (tx.IsCoinBase) + { + // Coinbase transactions have no inputs to fetch. return true; } - catch (IOException) + + StringBuilder queryBuilder = new StringBuilder(); + + queryBuilder.Append("select o.*, m.[TransactionHash] from [Outputs] o left join [MerkleNodes] m on (m.[nMerkleNodeID] = o.[nMerkleNodeID]) where "); + + for (var i = 0; i < tx.vin.Length; i++) { - // I/O error - return false; + 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) + )); } - catch (Exception) + + var queryResults = dbConn.Query(queryBuilder.ToString()); + + foreach (var item in queryResults) { - // Some serialization error - return false; + if (item.IsSpent) + { + return false; // Already spent + } + + var inputsKey = new COutPoint(item.TransactionHash, item.nOut); + + // Add output data to dictionary + inputs.Add(inputsKey, item.getTxOutItem()); } - } - /// - /// Previous block cursor - /// - [Ignore] - public CBlockStoreItem prev { - get { return CBlockStore.Instance.GetCursor(prevHash); } - } + if (queryResults.Count < tx.vin.Length) + { + if (IsBlock) + { + // It seems that some transactions are being spent in the same block. - /// - /// Next block cursor - /// - [Ignore] - public CBlockStoreItem next - { - get { return CBlockStore.Instance.GetCursor(nextHash); } - } + foreach (var txin in tx.vin) + { + var outPoint = txin.prevout; - [Ignore] - bool IsInMainChain - { - get { return (next != null); } - } + if (inputs.ContainsKey(outPoint)) + { + continue; // We have already seen this input. + } - /// - /// STake modifier generation flag - /// - [Ignore] - public bool GeneratedStakeModifier - { - get { return (BlockTypeFlag & BlockType.BLOCK_STAKE_MODIFIER) != 0; } - } + if (!queued.ContainsKey(outPoint)) + { + return false; // No such transaction + } - /// - /// Stake entropy bit - /// - [Ignore] - public uint StakeEntropyBit - { - get { return ((uint)(BlockTypeFlag & BlockType.BLOCK_STAKE_ENTROPY) >> 1); } - } + // Add output data to dictionary + inputs.Add(outPoint, queued[outPoint]); - /// - /// Sets stake modifier and flag. - /// - /// New stake modifier. - /// Set generation flag? - public void SetStakeModifier(long nModifier, bool fGeneratedStakeModifier) - { - nStakeModifier = nModifier; - if (fGeneratedStakeModifier) - BlockTypeFlag |= BlockType.BLOCK_STAKE_MODIFIER; - } + // Mark output as spent + // queued[outPoint].IsSpent = true; + } + } + else + { + // Unconfirmed transaction + + foreach (var txin in tx.vin) + { + var outPoint = txin.prevout; + CTransaction txPrev; + + if (!mapUnconfirmedTx.TryGetValue(outPoint.hash, out txPrev)) + { + return false; // No such transaction + } + + if (outPoint.n > txPrev.vout.Length) + { + Invalid = true; + + return false; // nOut is out of range + } + + // TODO: return inputs from map + throw new NotImplementedException(); + + } + + return false; + } + } - /// - /// Set entropy bit. - /// - /// Entropy bit value (0 or 1). - /// False if value is our of range. - public bool SetStakeEntropyBit(byte nEntropyBit) - { - if (nEntropyBit > 1) - return false; - BlockTypeFlag |= (nEntropyBit != 0 ? BlockType.BLOCK_STAKE_ENTROPY : 0); return true; } - /// - /// Set proof-of-stake flag. - /// - public void SetProofOfStake() + private bool AddItemToIndex(ref CBlockStoreItem itemTemplate, ref CBlock block) { - BlockTypeFlag |= BlockType.BLOCK_PROOF_OF_STAKE; - } + uint256 blockHash = itemTemplate.Hash; - /// - /// Block has no proof-of-stake flag. - /// - [Ignore] - public bool IsProofOfWork - { - get { return (BlockTypeFlag & BlockType.BLOCK_PROOF_OF_STAKE) == 0; } - } + if (blockMap.ContainsKey(blockHash)) + { + // Already have this block. + return false; + } - /// - /// Block has proof-of-stake flag set. - /// - [Ignore] - public bool IsProofOfStake - { - get { return (BlockTypeFlag & BlockType.BLOCK_PROOF_OF_STAKE) != 0; } - } + // Begin transaction + dbConn.BeginTransaction(); - /// - /// Chain trust score. - /// - [Ignore] - public uint256 nChainTrust { - get + // Compute chain trust score + itemTemplate.nChainTrust = (itemTemplate.prev != null ? itemTemplate.prev.nChainTrust : 0) + itemTemplate.nBlockTrust; + + if (!itemTemplate.SetStakeEntropyBit(Entropy.GetStakeEntropyBit(itemTemplate.nHeight, blockHash))) { - if (ChainTrust.Length != 32) - { - byte[] tmp = ChainTrust; - Array.Resize(ref tmp, 32); - ChainTrust = tmp; - } + return false; // SetStakeEntropyBit() failed + } - return ChainTrust; + // compute stake modifier + long nStakeModifier = 0; + bool fGeneratedStakeModifier = false; + if (!StakeModifier.ComputeNextStakeModifier(itemTemplate, ref nStakeModifier, ref fGeneratedStakeModifier)) + { + return false; // ComputeNextStakeModifier() failed } - set { ChainTrust = Interop.TrimArray(value); } - } - /// - /// Block trust score. - /// - [Ignore] - public uint256 nBlockTrust - { - get + itemTemplate.SetStakeModifier(nStakeModifier, fGeneratedStakeModifier); + itemTemplate.nStakeModifierChecksum = StakeModifier.GetStakeModifierChecksum(ref itemTemplate); + + // TODO: verify stake modifier checkpoints + + // Add to index + if (block.IsProofOfStake) { - uint256 nTarget = 0; - nTarget.Compact = nBits; + itemTemplate.SetProofOfStake(); + + itemTemplate.prevoutStake = block.vtx[1].vin[0].prevout; + itemTemplate.nStakeTime = block.vtx[1].nTime; - /* Old protocol */ - if (nTime < NetUtils.nChainChecksSwitchTime) + // Save proof-of-stake hash value + uint256 hashProofOfStake; + if (!GetProofOfStakeHash(ref blockHash, out hashProofOfStake)) { - return IsProofOfStake ? (new uint256(1) << 256) / (nTarget + 1) : 1; + return false; // hashProofOfStake not found } + itemTemplate.hashProofOfStake = hashProofOfStake; + } - /* New protocol */ + if (!itemTemplate.WriteToFile(ref fStreamReadWrite, ref block)) + { + return false; + } - // Calculate work amount for block - var nPoWTrust = NetUtils.nPoWBase / (nTarget + 1); + if (dbConn.Insert(itemTemplate) == 0) + { + return false; // Insert failed + } - // Set nPowTrust to 1 if we are checking PoS block or PoW difficulty is too low - nPoWTrust = (IsProofOfStake || !nPoWTrust) ? 1 : nPoWTrust; + // Get last RowID. + itemTemplate.ItemID = dbPlatform.SQLiteApi.LastInsertRowid(dbConn.Handle); - // Return nPoWTrust for the first 12 blocks - if (prev == null || prev.nHeight < 12) - return nPoWTrust; + if (!blockMap.TryAdd(blockHash, itemTemplate)) + { + return false; // blockMap add failed + } - CBlockStoreItem currentIndex = prev; + if (itemTemplate.nChainTrust > ChainParams.nBestChainTrust) + { + // New best chain - if (IsProofOfStake) + if (!SetBestChain(ref itemTemplate)) { - 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; - } + return false; // SetBestChain failed. + } + } - int nPoWCount = 0; + // Commit transaction + dbConn.Commit(); - // Check last 12 blocks type - while (prev.nHeight - currentIndex.nHeight < 12) - { - if (currentIndex.IsProofOfWork) - { - nPoWCount++; - } - currentIndex = currentIndex.prev; - } + return true; + } - // Return 1/3 of score if less than 3 PoW blocks found - if (nPoWCount < 3) - { - return nNewTrust / 3; - } + private bool SetBestChain(ref CBlockStoreItem cursor) + { + uint256 hashBlock = cursor.Hash; - return nNewTrust; - } - else + if (genesisBlockCursor == null && hashBlock == NetInfo.nHashGenesisBlock) + { + genesisBlockCursor = cursor; + } + else if (ChainParams.nHashBestChain == (uint256)cursor.prevHash) + { + if (!SetBestChainInner(cursor)) { - var nLastBlockTrust = prev.nChainTrust - prev.prev.nChainTrust; + return false; + } + } + else + { + // the first block in the new chain that will cause it to become the new best chain + var cursorIntermediate = cursor; - // 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); - } + // list of blocks that need to be connected afterwards + var secondary = new List(); - int nPoSCount = 0; + // 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) + { + secondary.Add(cursorIntermediate); + cursorIntermediate = cursorIntermediate.prev; + } - // Check last 12 blocks type - while (prev.nHeight - currentIndex.nHeight < 12) - { - if (currentIndex.IsProofOfStake) - { - nPoSCount++; - } - currentIndex = currentIndex.prev; - } + // Switch to new best branch + if (!Reorganize(cursorIntermediate)) + { + InvalidChainFound(cursor); + return false; // reorganize failed + } - // Return nPoWTrust + 2/3 of previous block score if less than 7 PoS blocks found - if (nPoSCount < 7) + // Connect further blocks + foreach (var currentCursor in secondary) + { + CBlock block; + if (!currentCursor.ReadFromFile(ref fStreamReadWrite, out block)) { - return nPoWTrust + (2 * nLastBlockTrust / 3); + // ReadFromDisk failed + break; } - nTarget.Compact = prev.nBits; - - if (!nTarget) + // errors now are not fatal, we still did a reorganisation to a new chain in a valid way + if (!SetBestChainInner(currentCursor)) { - return 0; + break; } + } + } - var nNewTrust = (new uint256(1) << 256) / (nTarget + 1); + bestBlockCursor = cursor; + nTimeBestReceived = Interop.GetTime(); + nTransactionsUpdated++; - // Return nPoWTrust + full trust score for previous block nBits - return nPoWTrust + nNewTrust; - } + if (!UpdateTopChain(cursor)) + { + return false; // unable to set top chain node. } + + return true; } - } + private void InvalidChainFound(CBlockStoreItem cursor) + { + throw new NotImplementedException(); + } - /// - /// Block type. - /// - public enum BlockType - { - BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block - BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier - BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier - }; - - /// - /// Transaction type. - /// - public enum TxType - { - TX_COINBASE, - TX_COINSTAKE, - TX_USER - } + private bool Reorganize(CBlockStoreItem cursorIntermediate) + { + // Find the fork + var fork = bestBlockCursor; + var longer = cursorIntermediate; - [Table("TransactionStorage")] - public class CTransactionStoreItem - { - /// - /// Transaction hash - /// - [PrimaryKey] - public byte[] TransactionHash { get; set; } + while (fork.ItemID != longer.ItemID) + { + while (longer.nHeight > fork.nHeight) + { + if ((longer = longer.prev) == null) + { + return false; // longer.prev is null + } + } - /// - /// Block hash - /// - [ForeignKey(typeof(CBlockStoreItem), Name = "Hash")] - public byte[] BlockHash { get; set; } + if (fork.ItemID == longer.ItemID) + { + break; + } - /// - /// Transaction type flag - /// - public TxType txType { get; set; } + if ((fork = fork.prev) == null) + { + return false; // fork.prev is null + } + } - /// - /// Tx position in file - /// - public long nTxPos { get; set; } + // List of what to disconnect + var disconnect = new List(); + for (var cursor = bestBlockCursor; cursor.ItemID != fork.ItemID; cursor = cursor.prev) + { + disconnect.Add(cursor); + } - /// - /// Transaction size - /// - public int nTxSize { get; set; } + // List of what to connect + var connect = new List(); + for (var cursor = cursorIntermediate; cursor.ItemID != fork.ItemID; cursor = cursor.prev) + { + connect.Add(cursor); + } + connect.Reverse(); - /// - /// Read transaction from file. - /// - /// Stream with read access. - /// CTransaction reference. - /// Result - public bool ReadFromFile(ref Stream reader, out CTransaction tx) - { - var buffer = new byte[CTransaction.nMaxTxSize]; - tx = null; + // Disconnect shorter branch + var txResurrect = new List(); + foreach (var blockCursor in disconnect) + { + CBlock block; + if (!blockCursor.ReadFromFile(ref fStreamReadWrite, out block)) + { + return false; // ReadFromFile for disconnect failed. + } + if (!DisconnectBlock(blockCursor, ref block)) + { + return false; // DisconnectBlock failed. + } - try + // Queue memory transactions to resurrect + foreach (var tx in block.vtx) + { + if (!tx.IsCoinBase && !tx.IsCoinStake) + { + txResurrect.Add(tx); + } + } + } + + // Connect longer branch + var txDelete = new List(); + foreach (var cursor in connect) { - reader.Seek(nTxPos, SeekOrigin.Begin); // Seek to transaction offset + CBlock block; + if (!cursor.ReadFromFile(ref fStreamReadWrite, out block)) + { + return false; // ReadFromDisk for connect failed + } - if (nTxSize != reader.Read(buffer, 0, nTxSize)) + if (!ConnectBlock(cursor, ref block)) { - return false; + // Invalid block + return false; // ConnectBlock failed } - tx = new CTransaction(buffer); + // Queue memory transactions to delete + foreach (var tx in block.vtx) + { + txDelete.Add(tx); + } + } - return true; + if (!UpdateTopChain(cursorIntermediate)) + { + return false; // UpdateTopChain failed } - catch (IOException) + + // Resurrect memory transactions that were in the disconnected branch + foreach (var tx in txResurrect) { - // I/O error - return false; + mapUnconfirmedTx.TryAdd(tx.Hash, tx); } - catch (TransactionConstructorException) + + // Delete redundant memory transactions that are in the connected branch + foreach (var tx in txDelete) { - // Constructor error - return false; + CTransaction dummy; + mapUnconfirmedTx.TryRemove(tx.Hash, out dummy); } + + return true; // Done } - } - public class CBlockStore : IDisposable - { - public const uint nMagicNumber = 0xe5e9e8e4; + private bool DisconnectBlock(CBlockStoreItem blockCursor, ref CBlock block) + { + throw new NotImplementedException(); + } - private bool disposed = false; - private object LockObj = new object(); + private bool SetBestChainInner(CBlockStoreItem cursor) + { + uint256 hash = cursor.Hash; + CBlock block; + if (!cursor.ReadFromFile(ref fStreamReadWrite, out block)) + { + return false; // Unable to read block from file. + } - /// - /// SQLite connection object. - /// - private SQLiteConnection dbConn; + // Adding to current best branch + if (!ConnectBlock(cursor, ref block) || !UpdateTopChain(cursor)) + { + InvalidChainFound(cursor); + return false; + } - /// - /// Block file. - /// - private string strBlockFile; + // Add to current best branch + var prevCursor = cursor.prev; + prevCursor.next = cursor; - /// - /// Index database file. - /// - private string strDbFile; + if (!UpdateDBCursor(ref prevCursor)) + { + return false; // unable to update + } - /// - /// Map of block tree nodes. - /// - private ConcurrentDictionary blockMap = new ConcurrentDictionary(); + // Delete redundant memory transactions + foreach (var tx in block.vtx) + { + CTransaction dummy; + mapUnconfirmedTx.TryRemove(tx.Hash, out dummy); + } - /// - /// Orphaned blocks map. - /// - private ConcurrentDictionary orphanMap = new ConcurrentDictionary(); - private ConcurrentDictionary orphanMapByPrev = new ConcurrentDictionary(); + return true; + } - /// - /// Map of unspent items. - /// - private ConcurrentDictionary txMap = new ConcurrentDictionary(); + private bool ConnectBlock(CBlockStoreItem cursor, ref CBlock block, bool fJustCheck = false) + { + // 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. + } - public static CBlockStore Instance; + bool fScriptChecks = cursor.nHeight >= Checkpoints.TotalBlocksEstimate; + var scriptFlags = scriptflag.SCRIPT_VERIFY_NOCACHE | scriptflag.SCRIPT_VERIFY_P2SH; - /// - /// Block file stream with read access - /// - private Stream fStreamReadWrite; + ulong nFees = 0; + ulong nValueIn = 0; + ulong nValueOut = 0; + uint nSigOps = 0; - /// - /// Init the block storage manager. - /// - /// Path to index database - /// Path to block file - public CBlockStore(string IndexDB = "blockstore.dat", string BlockFile = "blk0001.dat") - { - strDbFile = IndexDB; - strBlockFile = BlockFile; + var queuedMerkleNodes = new Dictionary(); + var queuedOutputs = new Dictionary(); - bool firstInit = !File.Exists(strDbFile); - dbConn = new SQLiteConnection(new SQLitePlatformGeneric(), strDbFile); + for (var nTx = 0; nTx < block.vtx.Length; nTx++) + { + var tx = block.vtx[nTx]; + var hashTx = tx.Hash; - fStreamReadWrite = File.Open(strBlockFile, FileMode.OpenOrCreate, FileAccess.ReadWrite); + if (!queuedMerkleNodes.ContainsKey(hashTx)) + { + var nTxPos = cursor.nBlockPos + block.GetTxOffset(nTx); + var mNode = new CMerkleNode(cursor.ItemID, nTxPos, tx); - Instance = this; + queuedMerkleNodes.Add(hashTx, mNode); + } - if (firstInit) - { - lock (LockObj) + Dictionary txouts; + if (GetOutputs(hashTx, out txouts)) { - // Create tables - dbConn.CreateTable(CreateFlags.AutoIncPK); - dbConn.CreateTable(CreateFlags.ImplicitPK); + // Do not allow blocks that contain transactions which 'overwrite' older transactions, + // unless those are already completely spent. + return false; + } - var genesisBlock = new CBlock( - Interop.HexToArray( - "01000000" + // nVersion=1 - "0000000000000000000000000000000000000000000000000000000000000000" + // prevhash is zero - "7b0502ad2f9f675528183f83d6385794fbcaa914e6d385c6cb1d866a3b3bb34c" + // merkle root - "398e1151" + // nTime=1360105017 - "ffff0f1e" + // nBits=0x1e0fffff - "d3091800" + // nNonce=1575379 - "01" + // nTxCount=1 - "01000000" + // nVersion=1 - "398e1151" + // nTime=1360105017 - "01" + // nInputs=1 - "0000000000000000000000000000000000000000000000000000000000000000" + // input txid is zero - "ffffffff" + // n=uint.maxValue - "4d" + // scriptSigLen=77 - "04ffff001d020f274468747470733a2f2f626974636f696e74616c6b2e6f72672f696e6465782e7068703f746f7069633d3133343137392e6d736731353032313936236d736731353032313936" + // scriptSig - "ffffffff" + // nSequence=uint.maxValue - "01" + // nOutputs=1 - "0000000000000000" + // nValue=0 - "00" + // scriptPubkeyLen=0 - "00000000" + // nLockTime=0 - "00" // sigLen=0 - )); + nSigOps += tx.LegacySigOpCount; + if (nSigOps > CBlock.nMaxSigOps) + { + return false; // too many sigops + } - // Write block to file. - var itemTemplate = new CBlockStoreItem() + var inputs = new Dictionary(); + + if (tx.IsCoinBase) + { + nValueOut += tx.nValueOut; + } + else + { + bool Invalid; + if (!FetchInputs(ref tx, ref queuedOutputs, ref inputs, true, out Invalid)) { - nHeight = 0 - }; + return false; // Unable to fetch some inputs. + } - itemTemplate.FillHeader(genesisBlock.header); + // Add in sigops done by pay-to-script-hash inputs; + // this is to prevent a "rogue miner" from creating + // an incredibly-expensive-to-validate block. + nSigOps += tx.GetP2SHSigOpCount(ref inputs); + if (nSigOps > CBlock.nMaxSigOps) + { + return false; // too many sigops + } - if (!AddItemToIndex(ref itemTemplate, ref genesisBlock)) + ulong nTxValueIn = tx.GetValueIn(ref inputs); + ulong nTxValueOut = tx.nValueOut; + + nValueIn += nTxValueIn; + nValueOut += nTxValueOut; + + if (!tx.IsCoinStake) { - throw new Exception("Unable to write genesis block"); + nFees += nTxValueIn - nTxValueOut; + } + + if (!ConnectInputs(ref tx, ref inputs, ref queuedOutputs, ref cursor, true, fScriptChecks, scriptFlags)) + { + return false; } } + + for (var i = 0u; i < tx.vout.Length; i++) + { + var outKey = new COutPoint(hashTx, i); + var outData = new TxOutItem() + { + nMerkleNodeID = -1, + nValue = tx.vout[i].nValue, + scriptPubKey = tx.vout[i].scriptPubKey, + IsSpent = false, + nOut = i + }; + + queuedOutputs.Add(outKey, outData); + } } - else + + if (!block.IsProofOfStake) { - var blockTreeItems = dbConn.Query("select * from [BlockStorage] order by [ItemId] asc"); + ulong nBlockReward = CBlock.GetProofOfWorkReward(cursor.nBits, nFees); - // Init list of block items - foreach (var item in blockTreeItems) + // Check coinbase reward + if (block.vtx[0].nValueOut > nBlockReward) { - blockMap.TryAdd(item.Hash, item); + return false; // coinbase reward exceeded } } - } - public bool GetTransaction(uint256 TxID, ref CTransaction tx) - { - var reader = new BinaryReader(fStreamReadWrite).BaseStream; - var QueryTx = dbConn.Query("select * from [TransactionStorage] where [TransactionHash] = ?", (byte[])TxID); + cursor.nMint = (long)(nValueOut - nValueIn + nFees); + cursor.nMoneySupply = (cursor.prev != null ? cursor.prev.nMoneySupply : 0) + (long)nValueOut - (long)nValueIn; - if (QueryTx.Count == 1) + if (!UpdateDBCursor(ref cursor)) { - return QueryTx[0].ReadFromFile(ref reader, out tx); + return false; // Unable to commit changes } - // Tx not found + if (fJustCheck) + { + return true; + } - return false; - } + // Flush merkle nodes. + var savedMerkleNodes = new Dictionary(); + foreach (var merklePair in queuedMerkleNodes) + { + var merkleNode = merklePair.Value; - private bool AddItemToIndex(ref CBlockStoreItem itemTemplate, ref CBlock block) - { - var writer = new BinaryWriter(fStreamReadWrite).BaseStream; - uint256 blockHash = itemTemplate.Hash; + if (!SaveMerkleNode(ref merkleNode)) + { + // Unable to save merkle tree cursor. + return false; + } - if (blockMap.ContainsKey(blockHash)) + savedMerkleNodes.Add(merklePair.Key, merkleNode); + } + + // Write queued transaction changes + var newOutpointItems = new List(); + var updatedOutpointItems = new List(); + foreach (var outPair in queuedOutputs) { - // Already have this block. - return false; + var outItem = outPair.Value; + + if (outItem.nMerkleNodeID == -1) + { + // This outpoint doesn't exist yet, adding to insert list. + + outItem.nMerkleNodeID = savedMerkleNodes[outPair.Key.hash].nMerkleNodeID; + newOutpointItems.Add(outItem); + } + else + { + // This outpount already exists, adding to update list. + + updatedOutpointItems.Add(outItem); + } } - // Compute chain trust score - itemTemplate.nChainTrust = (itemTemplate.prev != null ? itemTemplate.prev.nChainTrust : 0) + itemTemplate.nBlockTrust; + if (updatedOutpointItems.Count != 0 && !UpdateOutpoints(ref updatedOutpointItems)) + { + return false; // Unable to update outpoints + } - if (!itemTemplate.SetStakeEntropyBit(Entropy.GetStakeEntropyBit(itemTemplate.nHeight, blockHash))) + if (newOutpointItems.Count != 0 && !InsertOutpoints(ref newOutpointItems)) { - return false; // SetStakeEntropyBit() failed + return false; // Unable to insert outpoints } - // TODO: set stake entropy bit, record proof-of-stake hash value + return true; + } - // TODO: compute stake modifier + /// + /// Insert set of new outpoints + /// + /// List of TxOutItem objects. + /// Result + private bool InsertOutpoints(ref List newOutpointItems) + { + return (dbConn.InsertAll(newOutpointItems, false) != 0); + } - // Add to index - if (block.IsProofOfStake) - { - itemTemplate.SetProofOfStake(); - } - if (!itemTemplate.WriteToFile(ref writer, ref block)) + /// + /// Update set of outpoints + /// + /// List of TxOutItem objects. + /// Result + private bool UpdateOutpoints(ref List updatedOutpointItems) + { + return (dbConn.UpdateAll(updatedOutpointItems, false) != 0); + } + + /// + /// Insert merkle node into db and set actual record id value. + /// + /// Merkle node object reference. + /// Result + private bool SaveMerkleNode(ref CMerkleNode merkleNode) + { + if (dbConn.Insert(merkleNode) == 0) { return false; } - dbConn.Insert(itemTemplate); + merkleNode.nMerkleNodeID = dbPlatform.SQLiteApi.LastInsertRowid(dbConn.Handle); - // We have no SetBestChain and ConnectBlock/Disconnect block yet, so adding these transactions manually. - for (int i = 0; i < block.vtx.Length; i++) - { - // Handle trasactions + return true; + } + + private bool ConnectInputs(ref CTransaction tx, ref Dictionary inputs, ref Dictionary queued, ref CBlockStoreItem cursorBlock, bool fBlock, bool fScriptChecks, scriptflag scriptFlags) + { + // Take over previous transactions' spent items + // fBlock is true when this is called from AcceptBlock when a new best-block is added to the blockchain - if (!block.vtx[i].VerifyScripts()) + if (!tx.IsCoinBase) + { + ulong nValueIn = 0; + ulong nFees = 0; + for (uint i = 0; i < tx.vin.Length; i++) { - return false; - } + var prevout = tx.vin[i].prevout; + Contract.Assert(inputs.ContainsKey(prevout)); + var input = inputs[prevout]; - var nTxOffset = itemTemplate.nBlockPos + block.GetTxOffset(i); - TxType txnType = TxType.TX_USER; + CBlockStoreItem parentBlockCursor; + + if (input.nMerkleNodeID == -1) + { + // This input seems as is confirmed by the same block. + + if (!queued.ContainsKey(prevout)) + { + return false; // No such output has been queued by this block. + } + + // TODO: Ensure that neither coinbase nor coinstake outputs are + // available for spending in the generation block. + } + else + { + // This input has been confirmed by one of the earlier accepted blocks. + + var merkleItem = GetMerkleCursor(input, out parentBlockCursor); + + if (merkleItem == null) + { + return false; // Unable to find merkle node + } + + // If prev is coinbase or coinstake, check that it's matured + if (merkleItem.IsCoinBase || merkleItem.IsCoinStake) + { + if (cursorBlock.nHeight - parentBlockCursor.nHeight < NetInfo.nGeneratedMaturity) + { + return false; // tried to spend non-matured generation input. + } + } + + // check transaction timestamp + if (merkleItem.nTime > tx.nTime) + { + return false; // transaction timestamp earlier than input transaction + } + } + + // Check for negative or overflow input values + nValueIn += input.nValue; + if (!CTransaction.MoneyRange(input.nValue) || !CTransaction.MoneyRange(nValueIn)) + { + return false; // txin values out of range + } - if (block.vtx[i].IsCoinBase) - { - txnType = TxType.TX_COINBASE; } - else if (block.vtx[i].IsCoinStake) + + // The first loop above does all the inexpensive checks. + // Only if ALL inputs pass do we perform expensive ECDSA signature checks. + // Helps prevent CPU exhaustion attacks. + for (int i = 0; i < tx.vin.Length; i++) { - txnType = TxType.TX_COINSTAKE; + var prevout = tx.vin[i].prevout; + Contract.Assert(inputs.ContainsKey(prevout)); + var input = inputs[prevout]; + + // Check for conflicts (double-spend) + if (input.IsSpent) + { + return false; + } + + // Skip ECDSA signature verification when connecting blocks (fBlock=true) + // before the last blockchain checkpoint. This is safe because block merkle hashes are + // still computed and checked, and any change will be caught at the next checkpoint. + if (fScriptChecks) + { + // Verify signature + if (!ScriptCode.VerifyScript(tx.vin[i].scriptSig, input.scriptPubKey, tx, i, (int)scriptflag.SCRIPT_VERIFY_P2SH, 0)) + { + return false; // VerifyScript failed. + } + } + + // Mark outpoint as spent + input.IsSpent = true; + inputs[prevout] = input; + + // Write back + if (fBlock) + { + if (input.nMerkleNodeID != -1) + { + // Input has been confirmed earlier. + queued.Add(prevout, input); + } + else + { + // Input has been confirmed by current block. + queued[prevout] = input; + } + } } - var NewTxItem = new CTransactionStoreItem() + if (tx.IsCoinStake) + { + // ppcoin: coin stake tx earns reward instead of paying fee + ulong nCoinAge; + if (!tx.GetCoinAge(ref inputs, out nCoinAge)) + { + return false; // unable to get coin age for coinstake + } + + ulong nReward = tx.nValueOut - nValueIn; + + ulong nCalculatedReward = CBlock.GetProofOfStakeReward(nCoinAge, cursorBlock.nBits, tx.nTime) - tx.GetMinFee(1, false, CTransaction.MinFeeMode.GMF_BLOCK) + CTransaction.nCent; + + if (nReward > nCalculatedReward) + { + return false; // coinstake pays too much + } + } + else { - TransactionHash = block.vtx[i].Hash, - BlockHash = blockHash, - nTxPos = nTxOffset, - nTxSize = block.vtx[i].Size, - txType = txnType - }; - - dbConn.Insert(NewTxItem); + if (nValueIn < tx.nValueOut) + { + return false; // value in < value out + } + + // Tally transaction fees + ulong nTxFee = nValueIn - tx.nValueOut; + if (nTxFee < 0) + { + return false; // nTxFee < 0 + } + + nFees += nTxFee; + + if (!CTransaction.MoneyRange(nFees)) + { + return false; // nFees out of range + } + } + } - return blockMap.TryAdd(blockHash, itemTemplate); + return true; + } + + + /// + /// Set new top node or current best chain. + /// + /// + /// + private bool UpdateTopChain(CBlockStoreItem cursor) + { + ChainParams.HashBestChain = cursor.Hash; + ChainParams.nBestChainTrust = cursor.nChainTrust; + ChainParams.nBestHeight = cursor.nHeight; + + return dbConn.Update(ChainParams) != 0; + } + + /// + /// Try to find proof-of-stake hash in the map. + /// + /// Block hash + /// Proof-of-stake hash + /// Proof-of-Stake hash value + private bool GetProofOfStakeHash(ref uint256 blockHash, out uint256 hashProofOfStake) + { + return mapProofOfStake.TryGetValue(blockHash, out hashProofOfStake); } public bool AcceptBlock(ref CBlock block) @@ -740,7 +1044,7 @@ namespace Novacoin return false; } - CBlockStoreItem prevBlockCursor = null; + CBlockStoreItem prevBlockCursor; if (!blockMap.TryGetValue(block.header.prevHash, out prevBlockCursor)) { // Unable to get the cursor. @@ -753,7 +1057,7 @@ namespace Novacoin uint nHeight = prevBlockCursor.nHeight + 1; // Check timestamp against prev - if (NetUtils.FutureDrift(block.header.nTime) < prevBlockHeader.nTime) + if (NetInfo.FutureDrift(block.header.nTime) < prevBlockHeader.nTime) { // block's timestamp is too early return false; @@ -780,34 +1084,96 @@ namespace Novacoin if (!AddItemToIndex(ref itemTemplate, ref block)) { + dbConn.Rollback(); + return false; } return true; } - public bool GetBlock(uint256 blockHash, ref CBlock block) + /// + /// GEt block by hash. + /// + /// Block hash + /// Block object reference + /// Block position reference + /// Result + public bool GetBlock(uint256 blockHash, ref CBlock block, ref long nBlockPos) { - var reader = new BinaryReader(fStreamReadWrite).BaseStream; + CBlockStoreItem cursor; + + if (!blockMap.TryGetValue(blockHash, out cursor)) + { + return false; // Unable to fetch block cursor + } + + nBlockPos = cursor.nBlockPos; - var QueryBlock = dbConn.Query("select * from [BlockStorage] where [Hash] = ?", (byte[])blockHash); + return cursor.ReadFromFile(ref fStreamReadWrite, out block); + } + + /// + /// Get block and transaction by transaction hash. + /// + /// Transaction hash + /// Block reference + /// Block position reference + /// Result of operation + public bool GetBlockByTransactionID(uint256 TxID, out CBlock block, out long nBlockPos) + { + block = null; + nBlockPos = -1; - if (QueryBlock.Count == 1) + var queryResult = dbConn.Query("select b.* from [BlockStorage] b left join [MerkleNodes] m on (b.[ItemID] = m.[nParentBlockID]) where m.[TransactionHash] = ?", (byte[])TxID); + + if (queryResult.Count == 1) { - return QueryBlock[0].ReadFromFile(ref reader, out block); + CBlockStoreItem blockCursor = queryResult[0]; + + nBlockPos = blockCursor.nBlockPos; + + return blockCursor.ReadFromFile(ref fStreamReadWrite, out block); } - // Block not found + // Tx not found return false; } + public bool GetOutputs(uint256 transactionHash, out Dictionary txouts, bool fUnspentOnly=true) + { + txouts = null; + + var queryParams = new object[] { (byte[])transactionHash, fUnspentOnly ? OutputFlags.AVAILABLE : (OutputFlags.AVAILABLE | OutputFlags.SPENT) }; + var queryResult = dbConn.Query("select o.* from [Outputs] o left join [MerkleNodes] m on m.[nMerkleNodeID] = o.[nMerkleNodeID] where m.[TransactionHash] = ? and outputFlags = ?", queryParams); + + if (queryResult.Count != 0) + { + txouts = new Dictionary(); + + foreach (var o in queryResult) + { + var outpointKey = new COutPoint(transactionHash, o.nOut); + var outpointData = o; + + txouts.Add(outpointKey, outpointData); + } + + // There are some unspent inputs. + return true; + } + + // This transaction has been spent completely. + return false; + } + /// /// Get block cursor from map. /// /// block hash /// Cursor or null - public CBlockStoreItem GetCursor(uint256 blockHash) + public CBlockStoreItem GetMapCursor(uint256 blockHash) { if (blockHash == 0) { @@ -815,13 +1181,47 @@ namespace Novacoin return null; } - // First, check our block map. - CBlockStoreItem item = null; - if (blockMap.TryGetValue(blockHash, out item)) + CBlockStoreItem cursor = null; + blockMap.TryGetValue(blockHash, out cursor); + + return cursor; + } + + /// + /// Get merkle node cursor by output metadata. + /// + /// Output metadata object + /// Merkle node cursor or null + public CMerkleNode GetMerkleCursor(TxOutItem item, out CBlockStoreItem blockCursor) + { + blockCursor = null; + + // Trying to get cursor from the database. + var QueryMerkleCursor = dbConn.Query("select * from [MerkleNodes] where [nMerkleNodeID] = ?", item.nMerkleNodeID); + + if (QueryMerkleCursor.Count == 1) { - return item; + var merkleNode = QueryMerkleCursor[0]; + + // Search for block + var results = blockMap.Where(x => x.Value.ItemID == merkleNode.nParentBlockID).Select(x => x.Value).ToArray(); + + blockCursor = results[0]; + + return merkleNode; } + // Nothing found. + return null; + } + + /// + /// Load cursor from database. + /// + /// Block hash + /// Block cursor object + public CBlockStoreItem GetDBCursor(uint256 blockHash) + { // Trying to get cursor from the database. var QueryBlockCursor = dbConn.Query("select * from [BlockStorage] where [Hash] = ?", (byte[])blockHash); @@ -834,6 +1234,27 @@ namespace Novacoin return null; } + /// + /// Update cursor in memory and on disk. + /// + /// Block cursor + /// Result + public bool UpdateMapCursor(CBlockStoreItem cursor) + { + var original = blockMap[cursor.Hash]; + return blockMap.TryUpdate(cursor.Hash, cursor, original); + } + + /// + /// Update cursor record in database. + /// + /// Block cursor object + /// Result + public bool UpdateDBCursor(ref CBlockStoreItem cursor) + { + return dbConn.Update(cursor) != 0; + } + public bool ProcessBlock(ref CBlock block) { var blockHash = block.header.Hash; @@ -860,13 +1281,19 @@ namespace Novacoin if (block.IsProofOfStake) { - if (!block.SignatureOK || !block.vtx[1].VerifyScripts()) + // TODO: proof-of-stake validation + + uint256 hashProofOfStake = 0, targetProofOfStake = 0; + if (!StakeModifier.CheckProofOfStake(block.vtx[1], block.header.nBits, out hashProofOfStake, out targetProofOfStake)) { - // Proof-of-Stake signature validation failure. - return false; + 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: proof-of-stake validation } // TODO: difficulty verification @@ -934,13 +1361,10 @@ namespace Novacoin var intBuffer = new byte[4]; var fStream2 = File.OpenRead(BlockFile); - var readerForBlocks = new BinaryReader(fStream2).BaseStream; - readerForBlocks.Seek(nOffset, SeekOrigin.Begin); // Seek to previous offset + previous block length - - dbConn.BeginTransaction(); + fStream2.Seek(nOffset, SeekOrigin.Begin); // Seek to previous offset + previous block length - while (readerForBlocks.Read(buffer, 0, 4) == 4) // Read magic number + while (fStream2.Read(buffer, 0, 4) == 4) // Read magic number { var nMagic = BitConverter.ToUInt32(buffer, 0); if (nMagic != 0xe5e9e8e4) @@ -948,7 +1372,7 @@ namespace Novacoin throw new Exception("Incorrect magic number."); } - var nBytesRead = readerForBlocks.Read(buffer, 0, 4); + var nBytesRead = fStream2.Read(buffer, 0, 4); if (nBytesRead != 4) { throw new Exception("BLKSZ EOF"); @@ -956,9 +1380,9 @@ namespace Novacoin var nBlockSize = BitConverter.ToInt32(buffer, 0); - nOffset = readerForBlocks.Position; + nOffset = fStream2.Position; - nBytesRead = readerForBlocks.Read(buffer, 0, nBlockSize); + nBytesRead = fStream2.Read(buffer, 0, nBlockSize); if (nBytesRead == 0 || nBytesRead != nBlockSize) { @@ -979,18 +1403,9 @@ namespace Novacoin } int nCount = blockMap.Count; - Console.WriteLine("nCount={0}, Hash={1}, Time={2}", nCount, block.header.Hash, DateTime.Now); // Commit on each 100th block - - if (nCount % 100 == 0 && nCount != 0) - { - Console.WriteLine("Commit..."); - dbConn.Commit(); - dbConn.BeginTransaction(); - } + Console.WriteLine("nCount={0}, Hash={1}, NumTx={2}, Time={3}", nCount, block.header.Hash, block.vtx.Length, DateTime.Now); } - dbConn.Commit(); - return true; }