public void BenchmarkCreateChainFromBlocks()
{
BlockStore store = new BlockStore(@"E:\Bitcoin\blocks\", Network.Main);
Chain chain = null;
var fullBuild = Bench(() =>
{
chain = store.BuildChain();
});
chain.Changes.Rewind();
var rebuildFromMemory = Bench(() =>
{
var chain2 = new Chain(chain.Changes);
});
chain.Changes.Rewind();
var halfChain = new StreamObjectStream <ChainChange>();
for (int i = 0; i < 300000; i++)
{
halfChain.WriteNext(chain.Changes.ReadNext());
}
var halfBuild = Bench(() =>
{
var fullChain = store.BuildChain(halfChain);
});
}
public void CanSaveChain()
{
var stream = new StreamObjectStream <ChainChange>();
PersistantChain chain = new PersistantChain(Network.Main, stream);
AppendBlock(chain);
AppendBlock(chain);
var fork = AppendBlock(chain);
AppendBlock(chain);
stream.Rewind();
var chain2 = new PersistantChain(stream);
Assert.True(chain.SameTip(chain2));
stream.WriteNext(new ChainChange()
{
ChangeType = ChainChangeType.BackStep,
HeightOrBackstep = 1
});
stream.Rewind();
var chain3 = new PersistantChain(stream);
AssertHeight(stream, 3);
var actualFork = chain3.FindFork(chain);
Assert.Equal(fork.HashBlock, actualFork.HashBlock);
}
public Chain(ObjectStream<ChainChange> changes)
{
if(changes == null)
changes = new StreamObjectStream<ChainChange>();
changes.Rewind();
_Changes = changes;
Process();
}
public Account(ObjectStream<AccountEntry> entries)
{
if(entries == null)
entries = new StreamObjectStream<AccountEntry>();
entries.Rewind();
_Entries = entries;
Process();
}
public void CanDownloadChain()
{
using (var server = new NodeServer(Network.Main))
{
server.RegisterPeerTableRepository(PeerCache);
CancellationTokenSource cancel = new CancellationTokenSource();
StreamObjectStream <ChainChange> changes = new StreamObjectStream <ChainChange>(new MemoryStream());
var chain = new Chain(changes);
server.BuildChain(changes, cancel.Token);
}
}
public Chain BuildChain(ObjectStream <ChainChange> changes = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (changes == null)
{
changes = new StreamObjectStream <ChainChange>();
}
var chain = new Chain(Network, changes);
TraceCorrelation trace = new TraceCorrelation(NodeServerTrace.Trace, "Build chain");
using (trace.Open())
{
using (var pool = CreateNodeSet(3))
{
int height = pool.GetNodes().Max(o => o.FullVersion.StartHeight);
var listener = new PollMessageListener <IncomingMessage>();
pool.SendMessage(new GetHeadersPayload()
{
BlockLocators = chain.Tip.GetLocator()
});
using (pool.MessageProducer.AddMessageListener(listener))
{
while (chain.Height != height)
{
var before = chain.Tip;
var headers = listener.RecieveMessage(cancellationToken).Message.Payload as HeadersPayload;
if (headers != null)
{
foreach (var header in headers.Headers)
{
chain.GetOrAdd(header);
}
if (before.HashBlock != chain.Tip.HashBlock)
{
NodeServerTrace.Information("Chain progress : " + chain.Height + "/" + height);
pool.SendMessage(new GetHeadersPayload()
{
BlockLocators = chain.Tip.GetLocator()
});
}
}
}
}
}
}
return(chain);
}
public ScannerUser(KeyId keyId, int start, ScannerTester tester)
{
var folder = Path.Combine(tester._FolderName, tester.scanner.ToString());
TestUtils.EnsureNew(folder);
var chainStream = new StreamObjectStream <ChainChange>(File.Open(Path.Combine(folder, "Chain"), FileMode.OpenOrCreate));
var accountStream = new StreamObjectStream <AccountEntry>(File.Open(Path.Combine(folder, "Entries"), FileMode.OpenOrCreate));
_Id = keyId;
_Scanner = new PubKeyHashScanner(keyId);
_ScanState = new ScanState(new PubKeyHashScanner(keyId),
new Chain(chainStream),
new Account(accountStream),
start);
_Tester = tester;
}
public Account(Account copied, ObjectStream<AccountEntry> entries)
{
if(entries == null)
entries = new StreamObjectStream<AccountEntry>();
_Entries = entries;
copied.Entries.Rewind();
entries.Rewind();
foreach(var entry in copied.Entries.Enumerate())
{
if(_NextToProcess < copied._NextToProcess)
{
PushAccountEntry(entry);
}
else
entries.WriteNext(entry);
}
}
public Chain(Chain copied, ObjectStream<ChainChange> changes)
{
if(changes == null)
changes = new StreamObjectStream<ChainChange>();
AssertEmpty(changes);
_Changes = changes;
copied.Changes.Rewind();
foreach(var change in copied.Changes.Enumerate())
{
if(_NextToProcess < copied._NextToProcess)
{
ProcessAndRecord(change, null);
}
else
{
_Changes.WriteNext(change);
}
}
}
public void CanBuildChainIncrementally()
{
StreamObjectStream <ChainChange> changes = new StreamObjectStream <ChainChange>();
Chain main = new Chain(Network.Main, changes);
AppendBlock(main);
AppendBlock(main);
var forkPoint = AppendBlock(main);
AssertHeight(changes, 3);
AssertLength(changes, 4);
var current = AppendBlock(forkPoint, main);
var oldFork = AppendBlock(current, main);
AssertHeight(changes, 5);
AssertLength(changes, 6);
current = AppendBlock(forkPoint, main);
AssertHeight(changes, 5);
AssertLength(changes, 6);
current = AppendBlock(current, main);
AssertHeight(changes, 5);
AssertLength(changes, 6);
current = AppendBlock(current, main);
AssertHeight(changes, 6);
//1 back track (retour à 3) + height4 + height5 + height6
AssertLength(changes, 10);
current = AppendBlock(oldFork, main);
AssertHeight(changes, 6);
AssertLength(changes, 10);
//1 back track (retour à 3) + height4 + height5 + height6 + height7
current = AppendBlock(current, main);
AssertHeight(changes, 7);
AssertLength(changes, 15);
}
public void CanBuildChainIncrementally()
{
StreamObjectStream <ChainChange> changes = new StreamObjectStream <ChainChange>();
PersistantChain main = new PersistantChain(Network.Main, changes);
AppendBlock(main);
AppendBlock(main);
var forkPoint = AppendBlock(main);
AssertHeight(changes, 3);
AssertLength(changes, 4);
var current = AppendBlock(forkPoint, main);
var oldFork = AppendBlock(current, main);
AssertHeight(changes, 5);
AssertLength(changes, 6);
current = AppendBlock(forkPoint, main);
AssertHeight(changes, 5);
AssertLength(changes, 7);
current = AppendBlock(current, main);
AssertHeight(changes, 5);
AssertLength(changes, 8);
current = AppendBlock(current, main);
AssertHeight(changes, 6);
//1 back track (retour à 3) + 1 set tip
AssertLength(changes, 10);
current = AppendBlock(oldFork, main);
AssertHeight(changes, 6);
AssertLength(changes, 11);
//1 back track (retour à 3) + 1 set tip à 7
current = AppendBlock(current, main);
AssertHeight(changes, 7);
AssertLength(changes, 13);
}
public void CanBuildChainIncrementally()
{
StreamObjectStream<ChainChange> changes = new StreamObjectStream<ChainChange>();
Chain main = new Chain(Network.Main, changes);
AppendBlock(main);
AppendBlock(main);
var forkPoint = AppendBlock(main);
AssertHeight(changes, 3);
AssertLength(changes, 4);
var current = AppendBlock(forkPoint, main);
var oldFork = AppendBlock(current, main);
AssertHeight(changes, 5);
AssertLength(changes, 6);
current = AppendBlock(forkPoint, main);
AssertHeight(changes, 5);
AssertLength(changes, 6);
current = AppendBlock(current, main);
AssertHeight(changes, 5);
AssertLength(changes, 6);
current = AppendBlock(current, main);
AssertHeight(changes, 6);
//1 back track (retour à 3) + height4 + height5 + height6
AssertLength(changes, 10);
current = AppendBlock(oldFork, main);
AssertHeight(changes, 6);
AssertLength(changes, 10);
//1 back track (retour à 3) + height4 + height5 + height6 + height7
current = AppendBlock(current, main);
AssertHeight(changes, 7);
AssertLength(changes, 15);
}
public Chain(BlockHeader blockHeader, int height, ObjectStream<ChainChange> changes)
{
if(changes == null)
changes = new StreamObjectStream<ChainChange>();
AssertEmpty(changes);
_Changes = changes;
Initialize(blockHeader, height);
}
public void AssertHeight(StreamObjectStream <ChainChange> changes, int height)
{
changes.Rewind();
Assert.Equal(height, new PersistantChain(changes).Height);
}
private void AssertLength(StreamObjectStream <ChainChange> changes, int count)
{
changes.Rewind();
Assert.Equal(count, changes.Enumerate().Count());
}
private void AssertLength(StreamObjectStream<ChainChange> changes, int count)
{
changes.Rewind();
Assert.Equal(count, changes.Enumerate().Count());
}
public void CanSaveChain()
{
var stream = new StreamObjectStream<ChainChange>();
Chain chain = new Chain(Network.Main, stream);
AppendBlock(chain);
AppendBlock(chain);
var fork = AppendBlock(chain);
AppendBlock(chain);
stream.Rewind();
var chain2 = new Chain(stream);
Assert.True(chain.SameTip(chain2));
stream.WriteNext(new ChainChange()
{
Add = false,
HeightOrBackstep = 1
});
stream.Rewind();
var chain3 = new Chain(stream);
AssertHeight(stream, 3);
var actualFork = chain3.FindFork(chain);
Assert.Equal(fork.HashBlock, actualFork.HashBlock);
}
public void AssertHeight(StreamObjectStream<ChainChange> changes, int height)
{
changes.Rewind();
Assert.Equal(height, new Chain(changes).Height);
}
public ScannerUser(KeyId keyId, int start, ScannerTester tester)
{
var folder = Path.Combine(tester._FolderName, tester.scanner.ToString());
TestUtils.EnsureNew(folder);
var chainStream = new StreamObjectStream<ChainChange>(File.Open(Path.Combine(folder, "Chain"), FileMode.OpenOrCreate));
var accountStream = new StreamObjectStream<AccountEntry>(File.Open(Path.Combine(folder, "Entries"), FileMode.OpenOrCreate));
_Id = keyId;
_Scanner = new PubKeyHashScanner(keyId);
_ScanState = new ScanState(new PubKeyHashScanner(keyId),
new Chain(chainStream),
new Account(accountStream),
start);
_Tester = tester;
}
public Chain(BlockHeader blockHeader, int height, ObjectStream<ChainChange> changes)
{
if(changes == null)
changes = new StreamObjectStream<ChainChange>();
_Changes = changes;
changes.Rewind();
if(changes.EOF)
{
Initialize(blockHeader, height);
}
else
{
var first = changes.ReadNext();
if(first.BlockHeader.GetHash() != blockHeader.GetHash())
{
throw new InvalidOperationException("The first block of this stream is different than the expected one at height " + height);
}
if(first.HeightOrBackstep != height)
{
throw new InvalidOperationException("The first block of this stream has height " + first.HeightOrBackstep + " but expected is " + height);
}
changes.Rewind();
Process();
}
}
public void CanDownloadChain()
{
using(var server = new NodeServer(Network.Main))
{
server.RegisterPeerTableRepository(PeerCache);
CancellationTokenSource cancel = new CancellationTokenSource();
StreamObjectStream<ChainChange> changes = new StreamObjectStream<ChainChange>(new MemoryStream());
var chain = new Chain(changes);
server.BuildChain(changes, cancel.Token);
}
}
public Chain BuildChain(ObjectStream<ChainChange> changes = null, CancellationToken cancellationToken = default(CancellationToken))
{
if(changes == null)
changes = new StreamObjectStream<ChainChange>();
var chain = new Chain(Network, changes);
TraceCorrelation trace = new TraceCorrelation(NodeServerTrace.Trace, "Build chain");
using(trace.Open())
{
using(var pool = CreateNodeSet(3))
{
int height = pool.GetNodes().Max(o => o.FullVersion.StartHeight);
var listener = new PollMessageListener<IncomingMessage>();
pool.SendMessage(new GetHeadersPayload()
{
BlockLocators = chain.Tip.GetLocator()
});
using(pool.MessageProducer.AddMessageListener(listener))
{
while(chain.Height != height)
{
var before = chain.Tip;
var headers = listener.RecieveMessage(cancellationToken).Message.Payload as HeadersPayload;
if(headers != null)
{
foreach(var header in headers.Headers)
{
chain.GetOrAdd(header);
}
if(before.HashBlock != chain.Tip.HashBlock)
{
NodeServerTrace.Information("Chain progress : " + chain.Height + "/" + height);
pool.SendMessage(new GetHeadersPayload()
{
BlockLocators = chain.Tip.GetLocator()
});
}
}
}
}
}
}
return chain;
}
public Chain CreateSubChain(ChainedBlock from,
bool fromIncluded,
ChainedBlock to,
bool toIncluded,
ObjectStream<ChainChange> output = null)
{
if(output == null)
output = new StreamObjectStream<ChainChange>();
var blocks
=
to.EnumerateToGenesis()
.Skip(toIncluded ? 0 : 1)
.TakeWhile(c => c.HashBlock != from.HashBlock);
if(fromIncluded)
blocks = blocks.Concat(new ChainedBlock[] { from });
var array = blocks.Reverse().ToArray();
foreach(var b in array)
{
output.WriteNext(new ChainChange()
{
Add = true,
BlockHeader = b.Header,
HeightOrBackstep = (uint)b.Height
});
}
return new Chain(output);
}
