private void InternalStart()
{
if (!isInitted)
{
// write genesis block out to storage
coreStorage.AddGenesisBlock(ChainParams.GenesisChainedHeader);
coreStorage.TryAddBlock(ChainParams.GenesisBlock);
isInitted = true;
}
// startup workers
//this.utxoScanWorker.Start();
gcWorker.Start();
targetChainWorker.Start();
chainStateWorker.Start();
unconfirmedTxesWorker.Start();
pruningWorker.Start();
defragWorker.Start();
statsWorker.Start();
isStarted = true;
}
private void TestRollback(ITestStorageProvider provider)
{
var logger = LogManager.CreateNullLogger();
var sha256 = new SHA256Managed();
var blockProvider = new MainnetBlockProvider();
var blocks = Enumerable.Range(0, 500).Select(x => blockProvider.GetBlock(x)).ToList();
var genesisBlock = blocks[0];
var genesisHeader = new ChainedHeader(genesisBlock.Header, height: 0, totalWork: 0);
var genesisChain = Chain.CreateForGenesisBlock(genesisHeader);
var rules = new MainnetRules(logger);
using (var storageManager = provider.OpenStorageManager())
using (var coreStorage = new CoreStorage(storageManager, logger))
using (var chainStateBuilder = new ChainStateBuilder(logger, rules, coreStorage))
{
// add blocks to storage
coreStorage.AddGenesisBlock(ChainedHeader.CreateForGenesisBlock(blocks[0].Header));
foreach (var block in blocks)
{
coreStorage.TryAddBlock(block);
}
// calculate utxo forward and store its state at each step along the way
var expectedUtxos = new List <List <UnspentTx> >();
for (var blockIndex = 0; blockIndex < blocks.Count; blockIndex++)
{
var block = blocks[blockIndex];
var chainedHeader = new ChainedHeader(block.Header, blockIndex, 0);
chainStateBuilder.AddBlock(chainedHeader, block.Transactions);
using (var chainState = chainStateBuilder.ToImmutable())
{
expectedUtxos.Add(chainState.ReadUnspentTransactions().ToList());
}
}
// verify the utxo state before rolling back
//TODO verify the UTXO hash hard-coded here is correct
var expectedUtxoHash = UInt256.Parse("609eb5882e0b71a707fb876c844fbfe6b4579e04eb27c7c0cefbb7478bac737b", NumberStyles.HexNumber);
using (var utxoStream = new UtxoStream(logger, expectedUtxos.Last()))
{
var utxoHash = new UInt256(sha256.ComputeDoubleHash(utxoStream));
Assert.AreEqual(expectedUtxoHash, utxoHash);
}
expectedUtxos.RemoveAt(expectedUtxos.Count - 1);
// roll utxo backwards and validate its state at each step along the way
for (var blockIndex = blocks.Count - 1; blockIndex >= 1; blockIndex--)
{
var block = blocks[blockIndex];
var chainedHeader = new ChainedHeader(block.Header, blockIndex, 0);
var blockTxes = block.Transactions.Select((tx, txIndex) => new BlockTx(txIndex, 0, tx.Hash, /*pruned:*/ false, tx));
chainStateBuilder.RollbackBlock(chainedHeader, blockTxes);
var expectedUtxo = expectedUtxos.Last();
expectedUtxos.RemoveAt(expectedUtxos.Count - 1);
List <UnspentTx> actualUtxo;
using (var chainState = chainStateBuilder.ToImmutable())
{
actualUtxo = chainState.ReadUnspentTransactions().ToList();
}
CollectionAssert.AreEqual(expectedUtxo, actualUtxo, "UTXO differs at height: {0}".Format2(blockIndex));
}
}
}
private void TestRollback(ITestStorageProvider provider)
{
ConsoleLoggingModule.Configure();
var logger = LogManager.GetCurrentClassLogger();
var blockCount = 10.THOUSAND();
var checkUtxoHashFrequencey = 1000;
var blockProvider = new TestNet3BlockProvider();
var blocks = blockProvider.ReadBlocks().Take(blockCount).ToList();
var genesisBlock = blocks[0];
var genesisHeader = new ChainedHeader(genesisBlock.Header, height: 0, totalWork: 0, dateSeen: DateTimeOffset.Now);
var genesisChain = Chain.CreateForGenesisBlock(genesisHeader);
var chainParams = new Testnet3Params();
var rules = new CoreRules(chainParams)
{
IgnoreScripts = true,
IgnoreSignatures = true,
IgnoreScriptErrors = true
};
using (var storageManager = provider.OpenStorageManager())
using (var coreStorage = new CoreStorage(storageManager))
using (var chainStateBuilder = new ChainStateBuilder(rules, coreStorage, storageManager))
{
// add blocks to storage
coreStorage.AddGenesisBlock(ChainedHeader.CreateForGenesisBlock(blocks[0].Header));
foreach (var block in blocks)
{
coreStorage.TryAddBlock(block);
}
// store empty utxo hash
var expectedUtxoHashes = new List <UInt256>();
using (var chainState = chainStateBuilder.ToImmutable())
expectedUtxoHashes.Add(UtxoCommitment.ComputeHash(chainState));
// calculate utxo forward and store its state at each step along the way
for (var blockIndex = 0; blockIndex < blocks.Count; blockIndex++)
{
logger.Info($"Adding: {blockIndex:N0}");
var block = blocks[blockIndex];
var chainedHeader = new ChainedHeader(block.Header, blockIndex, 0, DateTimeOffset.Now);
chainStateBuilder.AddBlockAsync(chainedHeader, block.Transactions.Select(
(tx, txIndex) => BlockTx.Create(txIndex, tx))).Wait();
if (blockIndex % checkUtxoHashFrequencey == 0 || blockIndex == blocks.Count - 1)
{
using (var chainState = chainStateBuilder.ToImmutable())
expectedUtxoHashes.Add(UtxoCommitment.ComputeHash(chainState));
}
}
// verify the utxo state before rolling back
var expectedLastUtxoHash = UInt256.ParseHex("5f155c7d8a5c850d5fb2566aec5110caa40e270184126d17022ae9780fd65fd9");
Assert.AreEqual(expectedLastUtxoHash, expectedUtxoHashes.Last());
expectedUtxoHashes.RemoveAt(expectedUtxoHashes.Count - 1);
// roll utxo backwards and validate its state at each step along the way
for (var blockIndex = blocks.Count - 1; blockIndex >= 0; blockIndex--)
{
logger.Info($"Rolling back: {blockIndex:N0}");
var block = blocks[blockIndex];
var chainedHeader = new ChainedHeader(block.Header, blockIndex, 0, DateTimeOffset.Now);
var blockTxes = block.Transactions.Select((tx, txIndex) => BlockTx.Create(txIndex, tx));
chainStateBuilder.RollbackBlock(chainedHeader, blockTxes);
if ((blockIndex - 1) % checkUtxoHashFrequencey == 0 || blockIndex == 0)
{
var expectedUtxoHash = expectedUtxoHashes.Last();
expectedUtxoHashes.RemoveAt(expectedUtxoHashes.Count - 1);
using (var chainState = chainStateBuilder.ToImmutable())
Assert.AreEqual(expectedUtxoHash, UtxoCommitment.ComputeHash(chainState));
}
}
// verify chain state was rolled all the way back
Assert.AreEqual(-1, chainStateBuilder.Chain.Height);
Assert.AreEqual(0, expectedUtxoHashes.Count);
// calculate utxo forward again
for (var blockIndex = 0; blockIndex < blocks.Count; blockIndex++)
{
logger.Info($"Adding: {blockIndex:N0}");
var block = blocks[blockIndex];
var chainedHeader = new ChainedHeader(block.Header, blockIndex, 0, DateTimeOffset.Now);
chainStateBuilder.AddBlockAsync(chainedHeader, block.Transactions.Select(
(tx, txIndex) => BlockTx.Create(txIndex, tx))).Wait();
}
// verify final utxo state again
using (var chainState = chainStateBuilder.ToImmutable())
Assert.AreEqual(expectedLastUtxoHash, UtxoCommitment.ComputeHash(chainState));
}
}