public BlockRequestWorker(WorkerConfig workerConfig, Logger logger, LocalClient localClient, CoreDaemon coreDaemon) : base("BlockRequestWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger) { this.logger = logger; this.localClient = localClient; this.coreDaemon = coreDaemon; this.coreStorage = coreDaemon.CoreStorage; this.allBlockRequests = new ConcurrentDictionary <UInt256, BlockRequest>(); this.blockRequestsByPeer = new ConcurrentDictionary <Peer, ConcurrentDictionary <UInt256, DateTime> >(); this.missedBlockRequests = new ConcurrentDictionary <UInt256, BlockRequest>(); this.localClient.OnBlock += HandleBlock; this.coreDaemon.OnChainStateChanged += HandleChainStateChanged; this.coreDaemon.OnTargetChainChanged += HandleTargetChainChanged; this.coreStorage.BlockTxesMissed += HandleBlockTxesMissed; this.coreDaemon.BlockMissed += HandleBlockMissed; this.blockRequestDurationMeasure = new DurationMeasure(sampleCutoff: TimeSpan.FromMinutes(5)); this.blockDownloadRateMeasure = new RateMeasure(); this.duplicateBlockDownloadCountMeasure = new CountMeasure(TimeSpan.FromSeconds(30)); this.targetChainQueue = new List <ChainedHeader>(); this.targetChainQueueIndex = 0; this.targetChainLookAhead = 1; this.flushWorker = new WorkerMethod("BlockRequestWorker.FlushWorker", FlushWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue, logger: this.logger); this.flushQueue = new ConcurrentQueue <FlushBlock>(); this.flushBlocks = new ConcurrentSet <UInt256>(); this.diagnosticWorker = new WorkerMethod("BlockRequestWorker.DiagnosticWorker", DiagnosticWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.FromSeconds(10), maxIdleTime: TimeSpan.FromSeconds(10), logger: this.logger); }
public TestDaemon(Block genesisBlock = null) { this.random = new Random(); // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(new ConsoleLoggingModule()); // create the key pair that block rewards will be sent to this.txManager = this.kernel.Get <TransactionManager>(); var keyPair = this.txManager.CreateKeyPair(); this.coinbasePrivateKey = keyPair.Item1; this.coinbasePublicKey = keyPair.Item2; // initialize miner this.miner = this.kernel.Get <Miner>(); // create and mine the genesis block this.genesisBlock = genesisBlock ?? MineEmptyBlock(0); // log startup this.logger = kernel.Get <Logger>(); this.logger.Info("Starting up: {0}".Format2(DateTime.Now)); // add storage module this.kernel.Load(new MemoryStorageModule()); // add cache module this.kernel.Load(new CoreCacheModule()); // initialize block view this.blockCache = this.kernel.Get <BlockCache>(); // store genesis block this.blockCache[this.genesisBlock.Hash] = this.genesisBlock; // initialize unit test rules this.rules = this.kernel.Get <UnitTestRules>(); this.rules.SetGenesisBlock(this.genesisBlock); this.kernel.Bind <RulesEnum>().ToConstant(RulesEnum.TestNet2); this.kernel.Bind <IBlockchainRules>().ToConstant(rules); // initialize the blockchain daemon this.kernel.Bind <CoreDaemon>().ToSelf().InSingletonScope(); this.blockchainDaemon = this.kernel.Get <CoreDaemon>(); // start the blockchain daemon this.blockchainDaemon.Start(); // wait for initial work this.blockchainDaemon.ForceWorkAndWait(); // verify initial state Assert.AreEqual(0, this.blockchainDaemon.TargetBlock.Height); Assert.AreEqual(this.genesisBlock.Hash, this.blockchainDaemon.TargetChain.LastBlockHash); Assert.AreEqual(this.genesisBlock.Hash, this.blockchainDaemon.CurrentChain.LastBlockHash); }
public BlockRequestWorker(Logger logger, WorkerConfig workerConfig, LocalClient localClient, CoreDaemon blockchainDaemon, ChainedHeaderCache chainedHeaderCache, BlockCache blockCache) : base("BlockRequestWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger) { this.logger = logger; this.localClient = localClient; this.blockchainDaemon = blockchainDaemon; this.chainedHeaderCache = chainedHeaderCache; this.blockCache = blockCache; this.allBlockRequests = new ConcurrentDictionary <UInt256, DateTime>(); this.blockRequestsByPeer = new ConcurrentDictionary <IPEndPoint, ConcurrentDictionary <UInt256, DateTime> >(); this.missingBlockQueue = new SortedList <int, ChainedHeader>(); this.localClient.OnBlock += HandleBlock; this.blockchainDaemon.OnChainStateChanged += HandleChainStateChanged; this.blockchainDaemon.OnTargetChainChanged += HandleTargetChainChanged; this.blockCache.OnMissing += HandleBlockMissing; this.blockRequestDurationMeasure = new DurationMeasure(sampleCutoff: TimeSpan.FromMinutes(5)); this.blockDownloadRateMeasure = new RateMeasure(); this.duplicateBlockDownloadRateMeasure = new RateMeasure(); this.targetChainLookAhead = 1; this.criticalTargetChainLookAhead = 1; this.flushWorker = new WorkerMethod("BlockRequestWorker.FlushWorker", FlushWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue, logger: this.logger); this.flushQueue = new ConcurrentQueue <Tuple <RemoteNode, Block> >(); }
private CoreDaemon CreateExampleDaemon(out BlockProvider embeddedBlocks, out IStorageManager storageManager, int?maxHeight = null) { // retrieve first 10,000 testnet3 blocks embeddedBlocks = new BlockProvider("BitSharp.Examples.Blocks.TestNet3.zip"); // initialize in-memory storage storageManager = new MemoryStorageManager(); // intialize testnet3 rules (ignore script errors, script engine is not and is not intended to be complete) var chainParams = new Testnet3Params(); var rules = new CoreRules(chainParams) { IgnoreScriptErrors = true }; // initialize & start core daemon var coreDaemon = new CoreDaemon(rules, storageManager) { MaxHeight = maxHeight, IsStarted = true }; // add embedded blocks coreDaemon.CoreStorage.AddBlocks(embeddedBlocks.ReadBlocks()); // wait for core daemon to finish processing any available data coreDaemon.WaitForUpdate(); return(coreDaemon); }
public PeerWorker(WorkerConfig workerConfig, Logger logger, LocalClient localClient, CoreDaemon coreDaemon) : base("PeerWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger) { this.logger = logger; this.localClient = localClient; this.coreDaemon = coreDaemon; }
public MainWindowViewModel(IKernel kernel, WalletMonitor walletMonitor = null) { this.dispatcher = Dispatcher.CurrentDispatcher; this.kernel = kernel; this.blockchainDaemon = kernel.Get <CoreDaemon>(); this.localClient = kernel.Get <LocalClient>(); this.blockCache = kernel.Get <BlockCache>(); this.startTime = DateTime.UtcNow; this.runningTimeTimer = new DispatcherTimer(); runningTimeTimer.Tick += (sender, e) => { var runningTime = (DateTime.UtcNow - this.startTime); this.RunningTime = "{0:#,#00}:{1:mm':'ss}".Format2(Math.Floor(runningTime.TotalHours), runningTime); }; runningTimeTimer.Interval = TimeSpan.FromMilliseconds(100); runningTimeTimer.Start(); this.ratesTimer = new DispatcherTimer(); ratesTimer.Tick += (sender, e) => { this.BlockRate = this.blockchainDaemon.GetBlockRate(TimeSpan.FromSeconds(1)); this.TransactionRate = this.blockchainDaemon.GetTxRate(TimeSpan.FromSeconds(1)); this.InputRate = this.blockchainDaemon.GetInputRate(TimeSpan.FromSeconds(1)); this.BlockDownloadRate = this.localClient.GetBlockDownloadRate(TimeSpan.FromSeconds(1)); this.DuplicateBlockDownloadRate = this.localClient.GetDuplicateBlockDownloadRate(TimeSpan.FromSeconds(1)); }; ratesTimer.Interval = TimeSpan.FromSeconds(1); ratesTimer.Start(); this.viewChain = this.blockchainDaemon.CurrentChain; this.WinningBlockchainHeight = this.blockchainDaemon.TargetBlockHeight; this.CurrentBlockchainHeight = this.blockchainDaemon.CurrentChain.Height; this.DownloadedBlockCount = this.blockCache.Count; this.blockCache.OnAddition += (blockHash, block) => DownloadedBlockCount = this.blockCache.Count; this.blockCache.OnRemoved += (blockHash) => DownloadedBlockCount = this.blockCache.Count; this.blockchainDaemon.OnTargetBlockChanged += (sender, block) => WinningBlockchainHeight = this.blockchainDaemon.TargetBlockHeight; this.blockchainDaemon.OnChainStateChanged += (sender, chainState) => CurrentBlockchainHeight = this.blockchainDaemon.CurrentChain.Height; if (walletMonitor != null) { this.walletMonitor = walletMonitor; this.WalletEntries = new ObservableCollection <WalletEntry>(); this.walletMonitor.OnEntryAdded += HandleOnWalletEntryAdded; } }
internal PeerWorker(WorkerConfig workerConfig, LocalClient localClient, CoreDaemon coreDaemon, HeadersRequestWorker headersRequestWorker) : base("PeerWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime) { this.localClient = localClient; this.coreDaemon = coreDaemon; this.headersRequestWorker = headersRequestWorker; }
public async Task StartAsync() { await Task.WhenAll( // start the blockchain daemon Task.Run(() => CoreDaemon.Start()), // start p2p client Task.Run(() => LocalClient.Start(nodeConfig.ConnectToPeers))); }
public TestDaemon(Block genesisBlock = null, INinjectModule loggingModule = null, INinjectModule[] storageModules = null) { // initialize storage folder this.baseDirectoryCleanup = TempDirectory.CreateTempDirectory(out this.baseDirectory); // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(loggingModule ?? new ConsoleLoggingModule()); // log startup this.logger = LogManager.GetCurrentClassLogger(); this.logger.Info($"Starting up: {DateTime.Now}"); // initialize test blocks this.testBlocks = new TestBlocks(genesisBlock); // add storage module this.kernel.Load(storageModules ?? new[] { new MemoryStorageModule() }); // initialize unit test rules, allow validation methods to run testBlocks.Rules.ValidateTransactionAction = null; testBlocks.Rules.ValidationTransactionScriptAction = null; this.kernel.Bind<ChainType>().ToConstant(ChainType.Regtest); this.kernel.Bind<ICoreRules>().ToConstant(testBlocks.Rules); this.kernel.Bind<IChainParams>().ToConstant(testBlocks.ChainParams); // by default, don't run scripts in unit tests testBlocks.Rules.IgnoreScripts = true; // initialize the blockchain daemon this.kernel.Bind<CoreDaemon>().ToSelf().InSingletonScope(); this.coreDaemon = this.kernel.Get<CoreDaemon>(); try { this.coreStorage = this.coreDaemon.CoreStorage; // start the blockchain daemon this.coreDaemon.Start(); // wait for initial work this.coreDaemon.WaitForUpdate(); // verify initial state Assert.AreEqual(0, this.coreDaemon.TargetChainHeight); Assert.AreEqual(testBlocks.ChainParams.GenesisBlock.Hash, this.coreDaemon.TargetChain.LastBlock.Hash); Assert.AreEqual(testBlocks.ChainParams.GenesisBlock.Hash, this.coreDaemon.CurrentChain.LastBlock.Hash); } catch (Exception) { this.coreDaemon.Dispose(); throw; } }
public TestDaemon(Block genesisBlock = null, INinjectModule loggingModule = null, INinjectModule[] storageModules = null) { // initialize storage folder this.baseDirectoryCleanup = TempDirectory.CreateTempDirectory(out this.baseDirectory); // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(loggingModule ?? new ConsoleLoggingModule()); // log startup this.logger = LogManager.GetCurrentClassLogger(); this.logger.Info($"Starting up: {DateTime.Now}"); // initialize test blocks this.testBlocks = new TestBlocks(genesisBlock); // add storage module this.kernel.Load(storageModules ?? new[] { new MemoryStorageModule() }); // initialize unit test rules, allow validation methods to run testBlocks.Rules.ValidateTransactionAction = null; testBlocks.Rules.ValidationTransactionScriptAction = null; this.kernel.Bind <ChainType>().ToConstant(ChainType.Regtest); this.kernel.Bind <ICoreRules>().ToConstant(testBlocks.Rules); this.kernel.Bind <IChainParams>().ToConstant(testBlocks.ChainParams); // by default, don't run scripts in unit tests testBlocks.Rules.IgnoreScripts = true; // initialize the blockchain daemon this.kernel.Bind <CoreDaemon>().ToSelf().InSingletonScope(); this.coreDaemon = this.kernel.Get <CoreDaemon>(); try { this.coreStorage = this.coreDaemon.CoreStorage; // start the blockchain daemon this.coreDaemon.Start(); // wait for initial work this.coreDaemon.WaitForUpdate(); // verify initial state Assert.AreEqual(0, this.coreDaemon.TargetChainHeight); Assert.AreEqual(testBlocks.ChainParams.GenesisBlock.Hash, this.coreDaemon.TargetChain.LastBlock.Hash); Assert.AreEqual(testBlocks.ChainParams.GenesisBlock.Hash, this.coreDaemon.CurrentChain.LastBlock.Hash); } catch (Exception) { this.coreDaemon.Dispose(); throw; } }
protected virtual void Dispose(bool disposing) { if (!disposed && disposing) { // shutdown LocalClient.Dispose(); CoreDaemon.Dispose(); Kernel.Dispose(); disposed = true; } }
public LocalClient(ChainType type, IKernel kernel, CoreDaemon coreDaemon, INetworkPeerStorage networkPeerStorage) { this.shutdownToken = new CancellationTokenSource(); this.type = type; this.kernel = kernel; this.coreDaemon = coreDaemon; this.chainParams = coreDaemon.ChainParams; this.coreStorage = coreDaemon.CoreStorage; this.networkPeerStorage = networkPeerStorage; this.messageRateMeasure = new RateMeasure(); this.headersRequestWorker = new HeadersRequestWorker( new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(50), maxIdleTime: TimeSpan.FromSeconds(5)), this, this.coreDaemon); this.blockRequestWorker = new BlockRequestWorker( new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(50), maxIdleTime: TimeSpan.FromSeconds(30)), this, this.coreDaemon); this.peerWorker = new PeerWorker( new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromSeconds(1), maxIdleTime: TimeSpan.FromSeconds(1)), this, this.coreDaemon, this.headersRequestWorker); this.listenWorker = new ListenWorker(this, this.peerWorker); this.statsWorker = new WorkerMethod("LocalClient.StatsWorker", StatsWorker, true, TimeSpan.FromSeconds(5), TimeSpan.FromMinutes(5)); this.peerWorker.PeerHandshakeCompleted += HandlePeerHandshakeCompleted; this.peerWorker.PeerDisconnected += HandlePeerDisconnected; this.blockRequestWorker.OnBlockFlushed += HandleBlockFlushed; switch (this.Type) { case ChainType.MainNet: Messaging.Port = 8333; Messaging.Magic = Messaging.MAGIC_MAIN; break; case ChainType.TestNet3: Messaging.Port = 18333; Messaging.Magic = Messaging.MAGIC_TESTNET3; break; case ChainType.Regtest: Messaging.Port = 18444; Messaging.Magic = Messaging.MAGIC_COMPARISON_TOOL; break; } }
public WalletMonitor(CoreDaemon coreDaemon, bool keepEntries = true) : base("WalletMonitor", initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(0), maxIdleTime: TimeSpan.MaxValue) { this.coreDaemon = coreDaemon; this.addressesByOutputScriptHash = new Dictionary <UInt256, List <MonitoredWalletAddress> >(); this.matcherAddresses = new List <MonitoredWalletAddress>(); this.keepEntries = keepEntries; this.entries = ImmutableList.CreateBuilder <WalletEntry>(); this.bitBalance = 0; this.coreDaemon.OnChainStateChanged += HandleChainStateChanged; }
public LocalClient(Logger logger, RulesEnum type, IKernel kernel, IBlockchainRules rules, CoreDaemon coreDaemon, NetworkPeerCache networkPeerCache) { this.shutdownToken = new CancellationTokenSource(); this.logger = logger; this.type = type; this.kernel = kernel; this.rules = rules; this.coreDaemon = coreDaemon; this.coreStorage = coreDaemon.CoreStorage; this.networkPeerCache = networkPeerCache; this.messageRateMeasure = new RateMeasure(); this.peerWorker = new PeerWorker( new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromSeconds(1), maxIdleTime: TimeSpan.FromSeconds(1)), this.logger, this, this.coreDaemon); this.listenWorker = new ListenWorker(this.logger, this, this.peerWorker); this.headersRequestWorker = new HeadersRequestWorker( new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(50), maxIdleTime: TimeSpan.FromSeconds(5)), this.logger, this, this.coreDaemon); this.blockRequestWorker = new BlockRequestWorker( new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(50), maxIdleTime: TimeSpan.FromSeconds(30)), this.logger, this, this.coreDaemon); this.statsWorker = new WorkerMethod("LocalClient.StatsWorker", StatsWorker, true, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(30), this.logger); this.peerWorker.PeerConnected += HandlePeerConnected; this.peerWorker.PeerDisconnected += HandlePeerDisconnected; switch (this.Type) { case RulesEnum.MainNet: Messaging.Port = 8333; Messaging.Magic = Messaging.MAGIC_MAIN; break; case RulesEnum.TestNet3: Messaging.Port = 18333; Messaging.Magic = Messaging.MAGIC_TESTNET3; break; case RulesEnum.ComparisonToolTestNet: Messaging.Port = 18444; Messaging.Magic = Messaging.MAGIC_COMPARISON_TOOL; break; } }
public MainWindowViewModel(IKernel kernel, WalletMonitor walletMonitor = null) { this.kernel = kernel; coreDaemon = kernel.Get <CoreDaemon>(); coreStorage = coreDaemon.CoreStorage; localClient = kernel.Get <LocalClient>(); this.walletMonitor = walletMonitor; startTime = DateTimeOffset.Now; runningTimeTimer = new DispatcherTimer(); runningTimeTimer.Tick += (sender, e) => { var runningTime = (DateTimeOffset.Now - startTime); RunningTime = $"{Math.Floor(runningTime.TotalHours):#,#00}:{runningTime:mm':'ss}"; }; runningTimeTimer.Interval = TimeSpan.FromMilliseconds(100); runningTimeTimer.Start(); WinningBlockchainHeight = -1; CurrentBlockchainHeight = -1; DownloadedBlockCount = -1; WalletHeight = -1; updateWorker = new WorkerMethod("", _ => { WinningBlockchainHeight = coreDaemon.TargetChainHeight; CurrentBlockchainHeight = coreDaemon.CurrentChain.Height; DownloadedBlockCount = coreStorage.BlockWithTxesCount; BlockRate = coreDaemon.GetBlockRate(); TransactionRate = coreDaemon.GetTxRate(); InputRate = coreDaemon.GetInputRate(); BlockDownloadRate = localClient.GetBlockDownloadRate(); DuplicateBlockDownloadCount = localClient.GetDuplicateBlockDownloadCount(); BlockMissCount = localClient.GetBlockMissCount(); if (walletMonitor != null) { WalletHeight = this.walletMonitor.WalletHeight; WalletEntriesCount = this.walletMonitor.EntriesCount; BitBalance = this.walletMonitor.BitBalance; BtcBalance = this.walletMonitor.BtcBalance; } return(Task.CompletedTask); }, initialNotify: true, minIdleTime: TimeSpan.FromSeconds(1), maxIdleTime: TimeSpan.FromSeconds(1)); updateWorker.Start(); }
public HeadersRequestWorker(WorkerConfig workerConfig, LocalClient localClient, CoreDaemon coreDaemon) : base("HeadersRequestWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime) { this.localClient = localClient; this.coreDaemon = coreDaemon; this.coreStorage = coreDaemon.CoreStorage; this.headersRequestsByPeer = new ConcurrentDictionary <Peer, DateTimeOffset>(); this.localClient.OnBlockHeaders += HandleBlockHeaders; this.coreDaemon.OnTargetChainChanged += HandleTargetChainChanged; this.flushWorker = new WorkerMethod("HeadersRequestWorker.FlushWorker", FlushWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue); this.flushQueue = new ConcurrentQueue <FlushHeaders>(); }
public HeadersRequestWorker(Logger logger, WorkerConfig workerConfig, LocalClient localClient, CoreDaemon blockchainDaemon, BlockHeaderCache blockHeaderCache) : base("HeadersRequestWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger) { this.logger = logger; this.localClient = localClient; this.blockchainDaemon = blockchainDaemon; this.blockHeaderCache = blockHeaderCache; this.headersRequestsByPeer = new ConcurrentDictionary <IPEndPoint, DateTime>(); this.localClient.OnBlockHeaders += HandleBlockHeaders; this.blockchainDaemon.OnTargetChainChanged += HandleTargetChainChanged; this.flushWorker = new WorkerMethod("HeadersRequestWorker.FlushWorker", FlushWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue, logger: this.logger); this.flushQueue = new ConcurrentQueue <Tuple <RemoteNode, IImmutableList <BlockHeader> > >(); }
public LocalClient(Logger logger, RulesEnum type, IKernel kernel, IBlockchainRules rules, CoreDaemon blockchainDaemon, BlockHeaderCache blockHeaderCache, ChainedHeaderCache chainedHeaderCache, TransactionCache transactionCache, BlockCache blockCache, NetworkPeerCache networkPeerCache) { this.shutdownToken = new CancellationTokenSource(); this.logger = logger; this.type = type; this.kernel = kernel; this.rules = rules; this.blockchainDaemon = blockchainDaemon; this.blockHeaderCache = blockHeaderCache; this.chainedHeaderCache = chainedHeaderCache; this.transactionCache = transactionCache; this.blockCache = blockCache; this.networkPeerCache = networkPeerCache; this.messageRateMeasure = new RateMeasure(); this.connectWorker = new WorkerMethod("LocalClient.ConnectWorker", ConnectWorker, true, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), this.logger); this.headersRequestWorker = kernel.Get <HeadersRequestWorker>( new ConstructorArgument("workerConfig", new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(50), maxIdleTime: TimeSpan.FromSeconds(30))), new ConstructorArgument("localClient", this)); this.blockRequestWorker = kernel.Get <BlockRequestWorker>( new ConstructorArgument("workerConfig", new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(50), maxIdleTime: TimeSpan.FromSeconds(30))), new ConstructorArgument("localClient", this)); this.statsWorker = new WorkerMethod("LocalClient.StatsWorker", StatsWorker, true, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(30), this.logger); switch (this.Type) { case RulesEnum.MainNet: Messaging.Port = 8333; Messaging.Magic = Messaging.MAGIC_MAIN; break; case RulesEnum.TestNet3: Messaging.Port = 18333; Messaging.Magic = Messaging.MAGIC_TESTNET3; break; case RulesEnum.ComparisonToolTestNet: Messaging.Port = 18444; Messaging.Magic = Messaging.MAGIC_COMPARISON_TOOL; break; } }
public MainnetSimulator() { this.random = new Random(); this.blockProvider = new MainnetBlockProvider(); // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(new ConsoleLoggingModule()); // log startup this.logger = kernel.Get <Logger>(); this.logger.Info("Starting up: {0}".Format2(DateTime.Now)); // add storage module this.kernel.Load(new MemoryStorageModule()); // add cache module this.kernel.Load(new CoreCacheModule()); // initialize block view this.blockCache = this.kernel.Get <BlockCache>(); // add rules module this.kernel.Load(new RulesModule(RulesEnum.MainNet)); MainnetRules.IgnoreScriptErrors = true; // initialize the blockchain daemon this.kernel.Bind <CoreDaemon>().ToSelf().InSingletonScope(); this.coreDaemon = this.kernel.Get <CoreDaemon>(); // start the blockchain daemon this.coreDaemon.Start(); // wait for initial work this.coreDaemon.ForceWorkAndWait(); // verify initial state Assert.AreEqual(0, this.coreDaemon.TargetBlock.Height); //Assert.AreEqual(this.genesisBlock.Hash, this.blockchainDaemon.TargetChain.LastBlock.Hash); //Assert.AreEqual(this.genesisBlock.Hash, this.blockchainDaemon.ChainState.LastBlockHash); }
public MainnetSimulator() { this.random = new Random(); this.blockProvider = new MainnetBlockProvider(); // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(new ConsoleLoggingModule()); // log startup this.logger = kernel.Get <Logger>(); this.logger.Info("Starting up: {0}".Format2(DateTime.Now)); // add storage module this.kernel.Load(new MemoryStorageModule()); // add rules module this.kernel.Load(new RulesModule(RulesEnum.MainNet)); // TODO ignore script errors in test daemon until scripting engine is completed var rules = this.kernel.Get <IBlockchainRules>(); rules.IgnoreScriptErrors = true; // initialize the blockchain daemon this.kernel.Bind <CoreDaemon>().ToSelf().InSingletonScope(); this.coreDaemon = this.kernel.Get <CoreDaemon>(); this.coreStorage = this.coreDaemon.CoreStorage; // start the blockchain daemon this.coreDaemon.Start(); // wait for initial work this.coreDaemon.WaitForUpdate(); // verify initial state Assert.AreEqual(0, this.coreDaemon.TargetChainHeight); Assert.AreEqual(rules.GenesisBlock.Hash, this.coreDaemon.TargetChain.LastBlockHash); Assert.AreEqual(rules.GenesisBlock.Hash, this.coreDaemon.CurrentChain.LastBlockHash); }
public Simulator(ChainType chainType) { // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(new ConsoleLoggingModule()); // log startup this.logger = LogManager.GetCurrentClassLogger(); this.logger.Info($"Starting up: {DateTime.Now}"); this.random = new Random(); this.blockProvider = TestBlockProvider.CreateForRules(chainType); // add storage module this.kernel.Load(new MemoryStorageModule()); // add rules module this.kernel.Load(new RulesModule(chainType)); // by default, don't run scripts in unit tests var rules = this.kernel.Get <ICoreRules>(); rules.IgnoreScripts = true; // initialize the blockchain daemon this.kernel.Bind <CoreDaemon>().ToSelf().InSingletonScope(); this.coreDaemon = this.kernel.Get <CoreDaemon>(); this.coreStorage = this.coreDaemon.CoreStorage; // start the blockchain daemon this.coreDaemon.Start(); // wait for initial work this.coreDaemon.WaitForUpdate(); // verify initial state Assert.AreEqual(0, this.coreDaemon.TargetChainHeight); Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, this.coreDaemon.TargetChain.LastBlock.Hash); Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, this.coreDaemon.CurrentChain.LastBlock.Hash); }
public Simulator(ChainType chainType) { // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(new ConsoleLoggingModule()); // log startup this.logger = LogManager.GetCurrentClassLogger(); this.logger.Info($"Starting up: {DateTime.Now}"); this.random = new Random(); this.blockProvider = TestBlockProvider.CreateForRules(chainType); // add storage module this.kernel.Load(new MemoryStorageModule()); // add rules module this.kernel.Load(new RulesModule(chainType)); // by default, don't run scripts in unit tests var rules = this.kernel.Get<ICoreRules>(); rules.IgnoreScripts = true; // initialize the blockchain daemon this.kernel.Bind<CoreDaemon>().ToSelf().InSingletonScope(); this.coreDaemon = this.kernel.Get<CoreDaemon>(); this.coreStorage = this.coreDaemon.CoreStorage; // start the blockchain daemon this.coreDaemon.Start(); // wait for initial work this.coreDaemon.WaitForUpdate(); // verify initial state Assert.AreEqual(0, this.coreDaemon.TargetChainHeight); Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, this.coreDaemon.TargetChain.LastBlock.Hash); Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, this.coreDaemon.CurrentChain.LastBlock.Hash); }
public BlockRequestWorker(WorkerConfig workerConfig, LocalClient localClient, CoreDaemon coreDaemon) : base("BlockRequestWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime) { this.localClient = localClient; this.coreDaemon = coreDaemon; this.coreStorage = coreDaemon.CoreStorage; this.allBlockRequests = new ConcurrentDictionary <UInt256, BlockRequest>(); this.blockRequestsByPeer = new ConcurrentDictionary <Peer, ConcurrentDictionary <UInt256, DateTimeOffset> >(); this.missedBlockRequests = new ConcurrentDictionary <UInt256, BlockRequest>(); this.localClient.OnBlock += HandleBlock; this.coreDaemon.OnChainStateChanged += HandleChainStateChanged; this.coreDaemon.OnTargetChainChanged += HandleTargetChainChanged; this.coreDaemon.BlockMissed += HandleBlockMissed; this.blockRequestDurationMeasure = new DurationMeasure(sampleCutoff: TimeSpan.FromMinutes(5)); this.blockDownloadRateMeasure = new RateMeasure(); this.duplicateBlockDownloadCountMeasure = new CountMeasure(TimeSpan.FromSeconds(30)); this.targetChainQueue = new List <ChainedHeader>(); this.targetChainQueueIndex = 0; this.targetChainLookAhead = 1; this.flushWorker = new ActionBlock <FlushBlock>((Action <FlushBlock>)FlushWorkerMethod, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }); this.flushQueue = new BufferBlock <FlushBlock>(); this.flushBlocks = new ConcurrentSet <UInt256>(); this.flushQueue.LinkTo(this.flushWorker, new DataflowLinkOptions { PropagateCompletion = true }); this.diagnosticWorker = new WorkerMethod("BlockRequestWorker.DiagnosticWorker", DiagnosticWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.FromSeconds(10), maxIdleTime: TimeSpan.FromSeconds(10)); }
public DummyMonitor(CoreDaemon coreDaemon) : base(coreDaemon, keepEntries: false) { AddAddress(new First10000Address()); AddAddress(new Top10000Address()); }
public static void AssertDaemonAtBlock(int expectedHeight, UInt256 expectedBlockHash, CoreDaemon daemon) { Assert.AreEqual(expectedHeight, daemon.TargetBlock.Height); Assert.AreEqual(expectedHeight, daemon.TargetChain.Height); Assert.AreEqual(expectedBlockHash, daemon.TargetChain.LastBlock.Hash); Assert.AreEqual(expectedHeight, daemon.CurrentChain.Height); Assert.AreEqual(expectedBlockHash, daemon.CurrentChain.LastBlockHash); }
public TestDaemon(Block genesisBlock = null) { this.random = new Random(); // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(new ConsoleLoggingModule()); // create the key pair that block rewards will be sent to this.txManager = this.kernel.Get <TransactionManager>(); var keyPair = this.txManager.CreateKeyPair(); this.coinbasePrivateKey = keyPair.Item1; this.coinbasePublicKey = keyPair.Item2; // initialize miner this.miner = this.kernel.Get <Miner>(); // create and mine the genesis block this.genesisBlock = genesisBlock ?? MineEmptyBlock(0); // log startup this.logger = kernel.Get <Logger>(); this.logger.Info("Starting up: {0}".Format2(DateTime.Now)); // add storage module this.kernel.Load(new MemoryStorageModule()); // initialize unit test rules this.rules = this.kernel.Get <UnitTestRules>(); this.rules.SetGenesisBlock(this.genesisBlock); this.kernel.Bind <RulesEnum>().ToConstant(RulesEnum.TestNet2); this.kernel.Bind <IBlockchainRules>().ToConstant(rules); // TODO ignore script errors in test daemon until scripting engine is completed this.rules.IgnoreScriptErrors = true; // initialize the blockchain daemon this.kernel.Bind <CoreDaemon>().ToSelf().InSingletonScope(); this.coreDaemon = this.kernel.Get <CoreDaemon>(); try { this.coreStorage = this.coreDaemon.CoreStorage; // start the blockchain daemon this.coreDaemon.Start(); // wait for initial work this.coreDaemon.WaitForUpdate(); // verify initial state Assert.AreEqual(0, this.coreDaemon.TargetChainHeight); Assert.AreEqual(this.genesisBlock.Hash, this.coreDaemon.TargetChain.LastBlockHash); Assert.AreEqual(this.genesisBlock.Hash, this.coreDaemon.CurrentChain.LastBlockHash); } catch (Exception) { this.coreDaemon.Dispose(); throw; } }
public CoreRpcServer(CoreDaemon coreDaemon, int port) { this.coreDaemon = coreDaemon; this.listener = new ListenerWorker(this, port); }
public MainWindow() { try { //TODO //************************************************************** var rulesType = RulesEnum.TestNet3; //var rulesType = RulesEnum.MainNet; var bypassValidation = false; var ignoreScripts = false; var ignoreSignatures = false; var ignoreScriptErrors = true; var enablePruning = false; var cleanData = false; var cleanChainState = false; //NOTE: Running with a cleaned chained state against a pruned blockchain does not work. // It will see the data is missing, but won't redownload the blocks. //************************************************************** // directories var baseDirectory = Config.LocalStoragePath; if (false && Debugger.IsAttached) { baseDirectory = Path.Combine(baseDirectory, "Debugger"); } //TODO if (cleanData) { try { Directory.Delete(Path.Combine(baseDirectory, "Data", rulesType.ToString()), recursive: true); } catch (IOException) { } } else if (cleanChainState) { try { Directory.Delete(Path.Combine(baseDirectory, "Data", rulesType.ToString(), "ChainState"), recursive: true); } catch (IOException) { } } // initialize kernel this.kernel = new StandardKernel(); // add logging module this.kernel.Load(new LoggingModule(baseDirectory, LogLevel.Info)); // log startup this.logger = kernel.Get <Logger>(); this.logger.Info("Starting up: {0}".Format2(DateTime.Now)); var modules = new List <INinjectModule>(); // add storage module #if TEST_TOOL modules.Add(new MemoryStorageModule()); #elif MEMORY modules.Add(new MemoryStorageModule()); #else modules.Add(new EsentStorageModule(baseDirectory, rulesType, cacheSizeMaxBytes: int.MaxValue - 1)); //ChainStateCursor.IndexOutputs = true; #endif // add cache modules modules.Add(new NodeCacheModule()); // add rules module modules.Add(new RulesModule(rulesType)); // load modules this.kernel.Load(modules.ToArray()); // initialize rules var rules = this.kernel.Get <IBlockchainRules>(); rules.BypassValidation = bypassValidation; rules.IgnoreScripts = ignoreScripts; rules.IgnoreSignatures = ignoreSignatures; rules.IgnoreScriptErrors = ignoreScriptErrors; // initialize the blockchain daemon this.coreDaemon = this.kernel.Get <CoreDaemon>(); this.kernel.Bind <CoreDaemon>().ToConstant(this.coreDaemon).InTransientScope(); #if DUMMY_MONITOR var dummyMonitor = new DummyMonitor(this.logger); blockchainDaemon.SubscribeChainStateVisitor(dummyMonitor); #endif // initialize p2p client this.localClient = this.kernel.Get <LocalClient>(); this.kernel.Bind <LocalClient>().ToConstant(this.localClient).InTransientScope(); // setup view model #if DUMMY_MONITOR this.viewModel = new MainWindowViewModel(this.kernel, dummyMonitor); #else this.viewModel = new MainWindowViewModel(this.kernel); #endif InitializeComponent(); this.viewModel.ViewBlockchainLast(); // start the blockchain daemon this.coreDaemon.Start(enablePruning); // start p2p client var startThread = new Thread(() => this.localClient.Start()); startThread.Name = "LocalClient.Start"; startThread.Start(); this.DataContext = this.viewModel; #if TEST_TOOL var bitcoinjThread = new Thread( () => { var projectFolder = Environment.CurrentDirectory; while (projectFolder.Contains(@"\BitSharp.Client")) { projectFolder = Path.GetDirectoryName(projectFolder); } File.Delete(Path.Combine(projectFolder, "Bitcoinj-comparison.log")); var javaProcessStartInfo = new ProcessStartInfo { FileName = @"C:\Program Files\Java\jdk1.7.0_25\bin\java.exe", WorkingDirectory = projectFolder, Arguments = @"-Djava.util.logging.config.file={0}\bitcoinj.log.properties -jar {0}\bitcoinj.jar".Format2(projectFolder), UseShellExecute = false }; var javaProcess = Process.Start(javaProcessStartInfo); }); bitcoinjThread.Start(); #endif } catch (Exception e) { if (this.logger != null) { this.logger.Fatal("Application failed", e); LogManager.Flush(); } else { Console.WriteLine(e); } Environment.Exit(-1); } }
public NodeRpcServer(CoreDaemon coreDaemon, int port) : base(coreDaemon, port) { this.coreDaemon = coreDaemon; }
public CoreRpcServer(Logger logger, CoreDaemon coreDaemon) { this.logger = logger; this.coreDaemon = coreDaemon; this.listener = new ListenerWorker(this, this.logger); }
public NodeRpcServer(Logger logger, CoreDaemon coreDaemon) : base(logger, coreDaemon) { this.coreDaemon = coreDaemon; }