// private static bool Emulator; public static void Start() { if (_started) { return; } _started = true; NetworkComms.EnableLogging(new LiteLogger(LiteLogger.LogMode.ConsoleOnly)); NetworkComms.IgnoreUnknownPacketTypes = true; var serializer = DPSManager.GetDataSerializer <NetworkCommsDotNet.DPSBase.ProtobufSerializer>(); NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(serializer, NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options); NetworkComms.AppendGlobalIncomingPacketHandler <ServerInfo>(ServerInfo.GetHeader(), ServerInfoReceived); PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast); PeerDiscovery.OnPeerDiscovered += OnPeerDiscovered; Connection.StartListening(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 0)); PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast); }
public void Connect() { Started = true; ParseTrackers(); try { if (CommonHelpers.GetLocalEndPoint(1, true) != null && VotingsUser.PeerDiscovery) { PeerDiscovery.MinTargetLocalIPPort = CommonHelpers.DiscoveryPort; PeerDiscovery.MaxTargetLocalIPPort = CommonHelpers.DiscoveryPort; PeerDiscovery.OnPeerDiscovered -= PeerDiscovered; PeerDiscovery.OnPeerDiscovered += PeerDiscovered; PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast, CommonHelpers.GetLocalEndPoint(CommonHelpers.DiscoveryPort)); } TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort), false); } catch { NetworkComms.Logger.Error("Can't start listener on this IP: " + CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort).ToString()); } NetworkComms.Logger.Warn("===== Client started ====="); ConnectToTrackers(); RequestPeers(); ConnectToPeers(); t.Start(); }
private Client() { NetworkComms.DisableLogging(); NetworkComms.IgnoreUnknownPacketTypes = true; var serializer = DPSManager.GetDataSerializer <ProtobufSerializer>(); NetworkComms.DefaultSendReceiveOptions.DataProcessors.Add( DPSManager.GetDataProcessor <RijndaelPSKEncrypter>()); NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(serializer, NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options); RijndaelPSKEncrypter.AddPasswordToOptions(NetworkComms.DefaultSendReceiveOptions.Options, Utility.PSK); NetworkComms.AppendGlobalIncomingPacketHandler <Ping>(Ping.Header, PingHandler); NetworkComms.AppendGlobalIncomingPacketHandler <ClassInfo>(ClassInfo.Header, ClassInfoHandler); NetworkComms.AppendGlobalIncomingPacketHandler <InstructorLogin>(InstructorLogin.Header, InstructorLoginHandler); NetworkComms.AppendGlobalIncomingPacketHandler <ClientInfo>(ClientInfo.Header, ClientInfoHandler); PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast); PeerDiscovery.OnPeerDiscovered += OnPeerDiscovered; //NetworkComms.AppendGlobalIncomingPacketHandler<byte[]>("PartialFileData", IncomingPartialFileData); //NetworkComms.AppendGlobalIncomingPacketHandler<SendInfo>("PartialFileDataInfo", // IncomingPartialFileDataInfo); //NetworkComms.AppendGlobalConnectionCloseHandler(OnConnectionClose); PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast); }
public static ConsensusManager CreateConsensusManager(Network network, string dataDir = null, ChainState chainState = null, InMemoryCoinView inMemoryCoinView = null) { string[] param = dataDir == null ? new string[] {} : new string[] { $"-datadir={dataDir}" }; var nodeSettings = new NodeSettings(network, args: param); ILoggerFactory loggerFactory = nodeSettings.LoggerFactory; IDateTimeProvider dateTimeProvider = DateTimeProvider.Default; network.Consensus.Options = new ConsensusOptions(); new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration().RegisterRules(network.Consensus); // Dont check PoW of a header in this test. network.Consensus.HeaderValidationRules.RemoveAll(x => x.GetType() == typeof(CheckDifficultyPowRule)); var consensusSettings = new ConsensusSettings(nodeSettings); var chain = new ConcurrentChain(network); if (inMemoryCoinView == null) { inMemoryCoinView = new InMemoryCoinView(chain.Tip.HashBlock); } var networkPeerFactory = new NetworkPeerFactory(network, dateTimeProvider, loggerFactory, new PayloadProvider().DiscoverPayloads(), new SelfEndpointTracker(loggerFactory), new Mock <IInitialBlockDownloadState>().Object, new ConnectionManagerSettings()); var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, new SelfEndpointTracker(loggerFactory)); var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, network, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager); var connectionSettings = new ConnectionManagerSettings(nodeSettings); var selfEndpointTracker = new SelfEndpointTracker(loggerFactory); var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, selfEndpointTracker, connectionSettings, new VersionProvider(), new Mock <INodeStats>().Object); if (chainState == null) { chainState = new ChainState(); } var peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager); var deployments = new NodeDeployments(network, chain); ConsensusRuleEngine consensusRules = new PowConsensusRuleEngine(network, loggerFactory, dateTimeProvider, chain, deployments, consensusSettings, new Checkpoints(), inMemoryCoinView, chainState, new InvalidBlockHashStore(new DateTimeProvider())).Register(); var tree = new ChainedHeaderTree(network, loggerFactory, new HeaderValidator(consensusRules, loggerFactory), new Checkpoints(), new ChainState(), new Mock <IFinalizedBlockInfo>().Object, consensusSettings, new InvalidBlockHashStore(new DateTimeProvider())); var consensus = new ConsensusManager(tree, network, loggerFactory, chainState, new IntegrityValidator(consensusRules, loggerFactory), new PartialValidator(consensusRules, loggerFactory), new FullValidator(consensusRules, loggerFactory), consensusRules, new Mock <IFinalizedBlockInfo>().Object, new Signals.Signals(), peerBanning, new Mock <IInitialBlockDownloadState>().Object, chain, new Mock <IBlockPuller>().Object, new Mock <IBlockStore>().Object, new Mock <IConnectionManager>().Object, new Mock <INodeStats>().Object, new NodeLifetime()); return(consensus); }
public static void DiscoverServer() { Net.ConfigurePeerDiscovery(); if (!PeerDiscovery.IsDiscoverable(Net.PEER_DISCOVERY_METHOD)) { PeerDiscovery.EnableDiscoverable(Net.PEER_DISCOVERY_METHOD); } PeerDiscovery.OnPeerDiscovered += PeerDiscovery_OnPeerDiscovered; PeerDiscovery.DiscoverPeersAsync(Net.PEER_DISCOVERY_METHOD); }
/// <summary> /// Start the TCP listener /// </summary> public static void Listen() { if (Net.ENABLE_DISCOVERY) { Net.ConfigurePeerDiscovery(); PeerDiscovery.EnableDiscoverable(Net.PEER_DISCOVERY_METHOD); } NetworkComms.EnableLogging(new LiteLoggerDebug(LiteLoggerDebug.LogMode.ConsoleOnly)); Connection.StartListening(Listener = new TCPConnectionListener(Net.SEND_RECEIVE_OPTIONS, ApplicationLayerProtocolStatus.Enabled, true), new IPEndPoint(IPAddress.Any, Net.DEFAULT_PORT)); }
public void PeerConnectorAddNode_PeerAlreadyConnected_Scenario1() { this.CreateTestContext("PeerConnectorAddNode_PeerAlreadyConnected_Scenario1"); var peerConnectorAddNode = new PeerConnectorAddNode(new AsyncLoopFactory(this.loggerFactory), DateTimeProvider.Default, this.loggerFactory, this.network, this.networkPeerFactory, this.nodeLifetime, this.nodeSettings, this.connectionSetting, this.peerAddressManager); var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(this.loggerFactory), this.loggerFactory, this.network, this.networkPeerFactory, this.nodeLifetime, this.nodeSettings, this.peerAddressManager); var connectionSettings = new ConnectionManagerSettings(); connectionSettings.Load(this.nodeSettings); IConnectionManager connectionManager = new ConnectionManager( DateTimeProvider.Default, this.loggerFactory, this.network, this.networkPeerFactory, this.nodeSettings, this.nodeLifetime, this.parameters, this.peerAddressManager, new IPeerConnector[] { peerConnectorAddNode }, peerDiscovery, connectionSettings); // Create a peer to add to the already connected peers collection. using (NodeBuilder builder = NodeBuilder.Create()) { CoreNode coreNode = builder.CreateStratisPowNode(); builder.StartAll(); using (NetworkPeer networkPeer = coreNode.CreateNetworkPeerClient()) { // Add the network peers to the connection manager's // add node collection. connectionManager.AddNodeAddress(networkPeer.PeerAddress.Endpoint); // Add the peer to the already connected // peer collection of connection manager. // // This is to simulate that a peer has successfully connected // and that the add node connector's Find method then won't // return the added node. connectionManager.AddConnectedPeer(networkPeer); // Re-initialize the add node peer connector so that it // adds the successful address to the address manager. peerConnectorAddNode.Initialize(connectionManager); // TODO: Once we have an interface on NetworkPeer we can test this properly. // The already connected peer should not be returned. //var peer = peerConnectorAddNode.FindPeerToConnectTo(); //Assert.Null(peer); } } }
private static async Task FindServer() { var start = DateTime.Now; PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast); while ((DateTime.Now - start).TotalSeconds < 20) { if (Server != null) { break; } await Task.Delay(TimeSpan.FromSeconds(7)); } }
public static void Start() { if (_started) { return; } _started = true; NetworkComms.DisableLogging(); var serializer = DPSManager.GetDataSerializer <ProtobufSerializer>(); NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(serializer, NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options); PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast); NetworkComms.AppendGlobalIncomingPacketHandler <AndroidInfo>(AndroidInfo.GetHeader(), AndroidHandler.HandShakeHandler); NetworkComms.AppendGlobalIncomingPacketHandler <StudentInfoRequest>(StudentInfoRequest.GetHeader(), AndroidHandler.StudentInfoRequested); NetworkComms.AppendGlobalIncomingPacketHandler <EndPointInfo>(EndPointInfo.GetHeader(), HandShakeHandler); NetworkComms.AppendGlobalIncomingPacketHandler <GetWork>(GetWork.GetHeader(), GetWorkHandler); NetworkComms.AppendGlobalIncomingPacketHandler <Login>(Login.GetHeader(), LoginHandler); NetworkComms.AppendGlobalIncomingPacketHandler <Logout>(Logout.GetHeader(), LogoutHandler); NetworkComms.AppendGlobalIncomingPacketHandler <SchedulesRequest>(SchedulesRequest.GetHeader(), AndroidHandler.ScheduleRequestHandler); NetworkComms.AppendGlobalIncomingPacketHandler <EnrollRequest>(EnrollRequest.GetHeader(), AndroidHandler.EnrollRequestHandler); NetworkComms.AppendGlobalIncomingPacketHandler <RegisterStudent>(RegisterStudent.GetHeader(), AndroidHandler.RegisterStudentHandler); NetworkComms.AppendGlobalIncomingPacketHandler <SaveWork>(SaveWork.GetHeader(), SaveWorkHandler); NetworkComms.AppendGlobalIncomingPacketHandler <GetCourses>(GetCourses.GetHeader(), AndroidHandler.GetCoursesHandler); NetworkComms.AppendGlobalIncomingPacketHandler <GetCoursesDesktop>(GetCoursesDesktop.GetHeader(), GetCoursesHandler); NetworkComms.AppendGlobalIncomingPacketHandler <Pong>(Pong.GetHeader(), PongHandler); NetworkComms.AppendGlobalIncomingPacketHandler <EnrollStudent>(EnrollStudent.GetHeader(), EnrollStudentHandler); NetworkComms.AppendGlobalIncomingPacketHandler <StartEnrollment>(StartEnrollment.GetHeader(), AndroidHandler.StartEnrollmentHandler); NetworkComms.AppendGlobalIncomingPacketHandler <AddSchedule>(AddSchedule.GetHeader(), AndroidHandler.AddScheduleHandler); NetworkComms.AppendGlobalIncomingPacketHandler <CommitEnrollment>(CommitEnrollment.GetHeader(), AndroidHandler.CommitEnrollmentHandler); NetworkComms.AppendGlobalIncomingPacketHandler <StatusRequest>(StatusRequest.GetHeader(), AndroidHandler.StatusRequestHandler); NetworkComms.AppendGlobalIncomingPacketHandler <CancelEnrollment>(CancelEnrollment.GetHeader(), AndroidHandler.CancelEnrollmentHandler); // try // { Connection.StartListening(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 0), true); // } // catch (Exception e) // { // // } }
public void StartConnection(EClientType type) { DiscoverPeersTimer.AutoReset = true; DiscoverPeersTimer.Interval = 1000; DiscoverPeersTimer.Elapsed += DiscoverPeersTimer_Elapsed; DiscoverPeersTimer.Start(); ClientId = new ClientIdData(Environment.MachineName, CommonDebug.GetOptionalNumberId(), type); PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast); PeerDiscovery.OnPeerDiscovered += PeerDiscovery_OnPeerDiscovered; PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast); NetworkComms.AppendGlobalConnectionEstablishHandler(conn => OnConnectionEstablished(conn)); NetworkComms.AppendGlobalConnectionCloseHandler(conn => OnConnectionClosed(conn)); }
private Server() { var serializer = DPSManager.GetDataSerializer <ProtobufSerializer>(); NetworkComms.DefaultSendReceiveOptions.DataProcessors.Add( DPSManager.GetDataProcessor <RijndaelPSKEncrypter>()); NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(serializer, NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options); RijndaelPSKEncrypter.AddPasswordToOptions(NetworkComms.DefaultSendReceiveOptions.Options, Utility.PSK); NetworkComms.DisableLogging(); NetworkComms.AppendGlobalIncomingPacketHandler <LogonInfo>(LogonInfo.Header, LogonInfoHandler); NetworkComms.AppendGlobalIncomingPacketHandler <Login>(Login.Header, LoginHandler); NetworkComms.AppendGlobalIncomingPacketHandler <Pong>(Pong.Header, PongHandler); PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast); }
public void Disconnect() { while (Peers.Count > 0) { Peers.First().DisconnectAny(); } while (Trackers.Count > 0) { Trackers.First().Disconnect(); } t.Stop(); PeerDiscovery.DisableDiscoverable(); Connection.StopListening(); NetworkComms.CloseAllConnections(); NetworkComms.Shutdown(); NetworkComms.Logger.Warn("===== Client stopped ====="); Started = false; }
/// <summary> /// Stop and deinitialize native Obj-C side gracefully. /// </summary> private static void StopAndDeinitializeNative() { #if (UNITY_IOS || UNITY_TVOS || UNITY_STANDALONE_OSX) && (!UNITY_EDITOR || UNITY_EDITOR_OSX || UNITY_EDITOR_OVERRIDE) if (_isDeinitialized) { return; } Session.StopSession(); ServiceAdvertiser.StopAdvertising(); CustomServiceAdvertiser.StopAdvertising(); PeerDiscovery.CloseBrowser(); CustomPeerDiscovery.StopDiscovery(); NativeMethods.Events.UMC_UMCUnityEvents_SetEventListener(null); IntPtr error; #if !UNITY_EDITOR_OSX && (UNITY_IOS || UNITY_TVOS) NativeMethods.UMCMediatorFacade.SetViewController(IntPtr.Zero, out error); #else NativeMethods.UMCMediatorFacade.SetMainWindow(IntPtr.Zero, out error); #endif _isDeinitialized = true; #endif }
public async Task InitializeAsync() { this.blockinfo = new List <Blockinfo>(); List <long> lst = blockinfoarr.Cast <long>().ToList(); for (int i = 0; i < lst.Count; i += 2) { this.blockinfo.Add(new Blockinfo { extranonce = (int)lst[i], nonce = (uint)lst[i + 1] }); } // Note that by default, these tests run with size accounting enabled. this.network = KnownNetworks.RegTest; byte[] hex = Encoders.Hex.DecodeData("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"); this.scriptPubKey = new Script(new[] { Op.GetPushOp(hex), OpcodeType.OP_CHECKSIG }); this.entry = new TestMemPoolEntryHelper(); this.ChainIndexer = new ChainIndexer(this.network); this.network.Consensus.Options = new ConsensusOptions(); IDateTimeProvider dateTimeProvider = DateTimeProvider.Default; var loggerFactory = ExtendedLoggerFactory.Create(); var nodeSettings = new NodeSettings(this.network, args: new string[] { "-checkpoints" }); var consensusSettings = new ConsensusSettings(nodeSettings); var inMemoryCoinView = new InMemoryCoinView(new HashHeightPair(this.ChainIndexer.Tip)); var nodeStats = new NodeStats(dateTimeProvider, nodeSettings, new Mock <IVersionProvider>().Object); this.cachedCoinView = new CachedCoinView(this.network, new Checkpoints(), inMemoryCoinView, dateTimeProvider, new LoggerFactory(), nodeStats, consensusSettings); var signals = new Signals.Signals(loggerFactory, null); var asyncProvider = new AsyncProvider(loggerFactory, signals); var connectionSettings = new ConnectionManagerSettings(nodeSettings); var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, new SelfEndpointTracker(loggerFactory, connectionSettings)); var networkPeerFactory = new NetworkPeerFactory(this.network, dateTimeProvider, loggerFactory, new PayloadProvider().DiscoverPayloads(), new SelfEndpointTracker(loggerFactory, connectionSettings), new Mock <IInitialBlockDownloadState>().Object, new ConnectionManagerSettings(nodeSettings), asyncProvider, peerAddressManager); var peerDiscovery = new PeerDiscovery(asyncProvider, loggerFactory, this.network, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager); var selfEndpointTracker = new SelfEndpointTracker(loggerFactory, connectionSettings); var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, this.network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, selfEndpointTracker, connectionSettings, new VersionProvider(), new Mock <INodeStats>().Object, asyncProvider, new PayloadProvider()); var peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager); var deployments = new NodeDeployments(this.network, this.ChainIndexer); var genesis = this.network.GetGenesis(); var chainState = new ChainState() { BlockStoreTip = new ChainedHeader(genesis.Header, genesis.GetHash(), 0) }; var consensusRulesContainer = new ConsensusRulesContainer(); foreach (var ruleType in this.network.Consensus.ConsensusRules.HeaderValidationRules) { consensusRulesContainer.HeaderValidationRules.Add(Activator.CreateInstance(ruleType) as HeaderValidationConsensusRule); } foreach (var ruleType in network.Consensus.ConsensusRules.FullValidationRules) { FullValidationConsensusRule rule = null; if (ruleType == typeof(FlushCoinviewRule)) { rule = new FlushCoinviewRule(new Mock <IInitialBlockDownloadState>().Object); } else { rule = Activator.CreateInstance(ruleType) as FullValidationConsensusRule; } consensusRulesContainer.FullValidationRules.Add(rule); } this.ConsensusRules = new PowConsensusRuleEngine(this.network, loggerFactory, dateTimeProvider, this.ChainIndexer, deployments, consensusSettings, new Checkpoints(), this.cachedCoinView, chainState, new InvalidBlockHashStore(dateTimeProvider), nodeStats, asyncProvider, consensusRulesContainer).SetupRulesEngineParent(); this.consensus = ConsensusManagerHelper.CreateConsensusManager(this.network, chainState: chainState, inMemoryCoinView: inMemoryCoinView, chainIndexer: this.ChainIndexer, consensusRules: this.ConsensusRules); await this.consensus.InitializeAsync(chainState.BlockStoreTip); this.entry.Fee(11); this.entry.Height(11); var dateTimeProviderSet = new DateTimeProviderSet { time = dateTimeProvider.GetTime(), timeutc = dateTimeProvider.GetUtcNow() }; this.DateTimeProvider = dateTimeProviderSet; this.mempool = new TxMempool(dateTimeProvider, new BlockPolicyEstimator(new MempoolSettings(nodeSettings), loggerFactory, nodeSettings), loggerFactory, nodeSettings); this.mempoolLock = new MempoolSchedulerLock(); // We can't make transactions until we have inputs // Therefore, load 100 blocks :) this.baseheight = 0; var blocks = new List <Block>(); this.txFirst = new List <Transaction>(); this.nonce = 0; for (int i = 0; i < this.blockinfo.Count; ++i) { Block block = this.network.CreateBlock(); block.Header.HashPrevBlock = this.consensus.Tip.HashBlock; block.Header.Version = 1; block.Header.Time = Utils.DateTimeToUnixTime(this.ChainIndexer.Tip.GetMedianTimePast()) + 1; Transaction txCoinbase = this.network.CreateTransaction(); txCoinbase.Version = 1; txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(this.blockinfo[i].extranonce), Op.GetPushOp(this.ChainIndexer.Height) }))); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this) txCoinbase.AddOutput(new TxOut(Money.Zero, new Script())); block.AddTransaction(txCoinbase); if (this.txFirst.Count == 0) { this.baseheight = this.ChainIndexer.Height; } if (this.txFirst.Count < 4) { this.txFirst.Add(block.Transactions[0]); } block.Header.Bits = block.Header.GetWorkRequired(this.network, this.ChainIndexer.Tip); block.UpdateMerkleRoot(); while (!block.CheckProofOfWork()) { block.Header.Nonce = ++this.nonce; } // Serialization sets the BlockSize property. block = Block.Load(block.ToBytes(), this.network.Consensus.ConsensusFactory); var res = await this.consensus.BlockMinedAsync(block); if (res == null) { throw new InvalidOperationException(); } blocks.Add(block); } // Just to make sure we can still make simple blocks this.newBlock = AssemblerForTest(this).Build(this.ChainIndexer.Tip, this.scriptPubKey); Assert.NotNull(this.newBlock); }
/// <summary> /// Creates the test chain with some default blocks and txs. /// </summary> /// <param name="network">Network to create the chain on.</param> /// <param name="scriptPubKey">Public key to create blocks/txs with.</param> /// <returns>Context object representing the test chain.</returns> public static async Task <ITestChainContext> CreateAsync(Network network, Script scriptPubKey, string dataDir) { NodeSettings nodeSettings = new NodeSettings(network.Name, network).LoadArguments(new string[] { $"-datadir={dataDir}" }); if (dataDir != null) { nodeSettings.DataDir = dataDir; } var loggerFactory = new ExtendedLoggerFactory(); IDateTimeProvider dateTimeProvider = DateTimeProvider.Default; network.Consensus.Options = new PowConsensusOptions(); ConsensusSettings consensusSettings = new ConsensusSettings(nodeSettings, loggerFactory); PowConsensusValidator consensusValidator = new PowConsensusValidator(network, new Checkpoints(), dateTimeProvider, loggerFactory); ConcurrentChain chain = new ConcurrentChain(network); CachedCoinView cachedCoinView = new CachedCoinView(new InMemoryCoinView(chain.Tip.HashBlock), DateTimeProvider.Default, loggerFactory); NetworkPeerFactory networkPeerFactory = new NetworkPeerFactory(network, dateTimeProvider, loggerFactory); var peerAddressManager = new PeerAddressManager(nodeSettings.DataFolder, loggerFactory); var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, Network.PurpleMain, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager); var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery); LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(chain, connectionManager, new LoggerFactory()); PeerBanning peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, nodeSettings); NodeDeployments deployments = new NodeDeployments(network, chain); ConsensusRules consensusRules = new ConsensusRules(network, loggerFactory, dateTimeProvider, chain, deployments, consensusSettings, new Checkpoints()).Register(new FullNodeBuilderConsensusExtension.CoreConsensusRules()); ConsensusLoop consensus = new ConsensusLoop(new AsyncLoopFactory(loggerFactory), consensusValidator, new NodeLifetime(), chain, cachedCoinView, blockPuller, deployments, loggerFactory, new ChainState(new InvalidBlockHashStore(dateTimeProvider)), connectionManager, dateTimeProvider, new Signals.Signals(), consensusSettings, nodeSettings, peerBanning, consensusRules); await consensus.StartAsync(); BlockPolicyEstimator blockPolicyEstimator = new BlockPolicyEstimator(new MempoolSettings(nodeSettings), loggerFactory, nodeSettings); TxMempool mempool = new TxMempool(dateTimeProvider, blockPolicyEstimator, loggerFactory, nodeSettings); MempoolSchedulerLock mempoolLock = new MempoolSchedulerLock(); // Simple block creation, nothing special yet: PowBlockAssembler blockAssembler = CreatePowBlockAssembler(network, consensus, chain, mempoolLock, mempool, dateTimeProvider, loggerFactory); BlockTemplate newBlock = blockAssembler.CreateNewBlock(scriptPubKey); chain.SetTip(newBlock.Block.Header); await consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext { Block = newBlock.Block }, network.Consensus, consensus.Tip) { CheckPow = false, CheckMerkleRoot = false }); List <BlockInfo> blockinfo = CreateBlockInfoList(); // We can't make transactions until we have inputs // Therefore, load 100 blocks :) int baseheight = 0; List <Block> blocks = new List <Block>(); List <Transaction> srcTxs = new List <Transaction>(); for (int i = 0; i < blockinfo.Count; ++i) { Block currentBlock = newBlock.Block.Clone(); // pointer for convenience currentBlock.Header.HashPrevBlock = chain.Tip.HashBlock; currentBlock.Header.Version = 1; currentBlock.Header.Time = Utils.DateTimeToUnixTime(chain.Tip.GetMedianTimePast()) + 1; Transaction txCoinbase = currentBlock.Transactions[0].Clone(); txCoinbase.Inputs.Clear(); txCoinbase.Version = 1; txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(blockinfo[i].extraNonce), Op.GetPushOp(chain.Height) }))); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this) txCoinbase.AddOutput(new TxOut(Money.Zero, new Script())); currentBlock.Transactions[0] = txCoinbase; if (srcTxs.Count == 0) { baseheight = chain.Height; } if (srcTxs.Count < 4) { srcTxs.Add(currentBlock.Transactions[0]); } currentBlock.UpdateMerkleRoot(); currentBlock.Header.Nonce = blockinfo[i].nonce; chain.SetTip(currentBlock.Header); await consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext { Block = currentBlock }, network.Consensus, consensus.Tip) { CheckPow = false, CheckMerkleRoot = false }); blocks.Add(currentBlock); } // Just to make sure we can still make simple blocks blockAssembler = CreatePowBlockAssembler(network, consensus, chain, mempoolLock, mempool, dateTimeProvider, loggerFactory); newBlock = blockAssembler.CreateNewBlock(scriptPubKey); MempoolValidator mempoolValidator = new MempoolValidator(mempool, mempoolLock, consensusValidator, dateTimeProvider, new MempoolSettings(nodeSettings), chain, cachedCoinView, loggerFactory, nodeSettings); return(new TestChainContext { MempoolValidator = mempoolValidator, SrcTxs = srcTxs }); }
private void RequestPeers() { //считаем сколько нужно пиров int needPeersCount = normalPeersCount - Peers.Where(peer => peer.Status == PeerStatus.Connected).Count(); if (needPeersCount <= 0) { return; } //сначала ищем пиры без трекера if (VotingsUser.PeerDiscovery) { try { PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast); } catch { } } //пиры подключенные прямо (сортируем по кол-ву запросов) var connectedPeersDirect = Peers.Where(peer => peer.Status == PeerStatus.Connected && peer.ConnectionMode == ConnectionMode.Direct) .OrderBy(peer => peer.PeersRequestsCount); //подключенные трекеры (сортируем по кол-ву запросов) var connectedTrackers = Trackers.Where(tracker => tracker.Status == TrackerStatus.Connected) .OrderBy(tracker => tracker.PeersRequestsCount); //пиры подключенные через трекер (сортируем по кол-ву запросов) var connectedPeersWithTracker = Peers.Where(peer => peer.Status == PeerStatus.Connected && peer.ConnectionMode == ConnectionMode.WithTracker) .OrderBy(peer => peer.PeersRequestsCount); //если есть подключенные пиры и трекеры if (connectedPeersDirect.Any() && connectedTrackers.Any()) { var firstPeerDirect = connectedPeersDirect.First(); var firstTracker = connectedTrackers.First(); //запрашиваем у первого прямого пира, если к нему было меньше запросов чем к первому трекеру if (firstPeerDirect.PeersRequestsCount <= firstTracker.PeersRequestsCount) { firstPeerDirect.RequestPeers(needPeersCount); } //если есть подключенные через трекеры пиры else if (connectedPeersWithTracker.Any()) { var firstPeerWithTracker = connectedPeersWithTracker.First(); //запрашиваем у первого трекера, если к нему было меньше запросов чем к первому подключенному через трекер пиру if (firstTracker.PeersRequestsCount <= firstPeerWithTracker.PeersRequestsCount) { firstTracker.RequestPeersFromTracker(needPeersCount); } else { firstPeerWithTracker.RequestPeers(needPeersCount); } } else { firstTracker.RequestPeersFromTracker(needPeersCount); } } else if (connectedPeersDirect.Any()) { var firstPeerDirect = connectedPeersDirect.First(); firstPeerDirect.RequestPeers(needPeersCount); } else if (connectedTrackers.Any()) { var firstTracker = connectedTrackers.First(); firstTracker.RequestPeersFromTracker(needPeersCount); } }
public TestContext() { this.Network = KnownNetworks.RegTest; this.chainIndexer = new ChainIndexer(this.Network); this.dateTimeProvider = new DateTimeProvider(); this.hashStore = new InvalidBlockHashStore(this.dateTimeProvider); this.coinView = new TestInMemoryCoinView(this.chainIndexer.Tip.HashBlock); this.HeaderValidator = new Mock <IHeaderValidator>(); this.HeaderValidator.Setup(hv => hv.ValidateHeader(It.IsAny <ChainedHeader>())).Returns(new ValidationContext()); this.nodeLifetime = new NodeLifetime(); this.ibd = new Mock <IInitialBlockDownloadState>(); this.BlockPuller = new Mock <IBlockPuller>(); this.BlockPuller.Setup(b => b.Initialize(It.IsAny <BlockPuller.OnBlockDownloadedCallback>())) .Callback <BlockPuller.OnBlockDownloadedCallback>((d) => { this.blockPullerBlockDownloadCallback = d; }); this.BlockStore = new Mock <IBlockStore>(); this.checkpoints = new Mock <ICheckpoints>(); this.ChainState = new Mock <IChainState>(); string[] param = new string[] { }; this.nodeSettings = new NodeSettings(this.Network, args: param); this.ConsensusSettings = new ConsensusSettings(this.nodeSettings); this.loggerFactory = this.nodeSettings.LoggerFactory; this.nodeStats = new NodeStats(this.dateTimeProvider, this.loggerFactory); var connectionSettings = new ConnectionManagerSettings(this.nodeSettings); this.selfEndpointTracker = new SelfEndpointTracker(this.loggerFactory, connectionSettings); this.Network.Consensus.Options = new ConsensusOptions(); this.signals = new Bitcoin.Signals.Signals(this.loggerFactory, null); this.asyncProvider = new AsyncProvider(this.loggerFactory, this.signals, this.nodeLifetime); // Dont check PoW of a header in this test. this.Network.Consensus.ConsensusRules.HeaderValidationRules.RemoveAll(x => x.GetType() == typeof(CheckDifficultyPowRule)); this.ChainedHeaderTree = new ChainedHeaderTree( this.Network, this.loggerFactory, this.HeaderValidator.Object, this.checkpoints.Object, this.ChainState.Object, this.FinalizedBlockMock.Object, this.ConsensusSettings, this.hashStore); this.peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, this.nodeSettings.DataFolder, this.loggerFactory, this.selfEndpointTracker); this.networkPeerFactory = new NetworkPeerFactory(this.Network, this.dateTimeProvider, this.loggerFactory, new PayloadProvider().DiscoverPayloads(), this.selfEndpointTracker, this.ibd.Object, new ConnectionManagerSettings(this.nodeSettings), this.asyncProvider, this.peerAddressManager); var peerDiscovery = new PeerDiscovery(this.asyncProvider, this.loggerFactory, this.Network, this.networkPeerFactory, this.nodeLifetime, this.nodeSettings, this.peerAddressManager); this.connectionManager = new ConnectionManager(this.dateTimeProvider, this.loggerFactory, this.Network, this.networkPeerFactory, this.nodeSettings, this.nodeLifetime, new NetworkPeerConnectionParameters(), this.peerAddressManager, new IPeerConnector[] { }, peerDiscovery, this.selfEndpointTracker, connectionSettings, new VersionProvider(), this.nodeStats, this.asyncProvider); this.deployments = new NodeDeployments(this.Network, this.chainIndexer); this.consensusRules = new PowConsensusRuleEngine(this.Network, this.loggerFactory, this.dateTimeProvider, this.chainIndexer, this.deployments, this.ConsensusSettings, this.checkpoints.Object, this.coinView, this.ChainState.Object, this.hashStore, this.nodeStats, this.asyncProvider, new ConsensusRulesContainer()); this.consensusRules.SetupRulesEngineParent(); var tree = new ChainedHeaderTree(this.Network, this.loggerFactory, this.HeaderValidator.Object, this.checkpoints.Object, this.ChainState.Object, this.FinalizedBlockMock.Object, this.ConsensusSettings, this.hashStore); this.PartialValidator = new Mock <IPartialValidator>(); this.FullValidator = new Mock <IFullValidator>(); this.peerBanning = new PeerBanning(this.connectionManager, this.loggerFactory, this.dateTimeProvider, this.peerAddressManager); this.IntegrityValidator.Setup(i => i.VerifyBlockIntegrity(It.IsAny <ChainedHeader>(), It.IsAny <Block>())) .Returns(new ValidationContext()); ConsensusManager consensusManager = new ConsensusManager(tree, this.Network, this.loggerFactory, this.ChainState.Object, this.IntegrityValidator.Object, this.PartialValidator.Object, this.FullValidator.Object, this.consensusRules, this.FinalizedBlockMock.Object, this.signals, this.peerBanning, this.ibd.Object, this.chainIndexer, this.BlockPuller.Object, this.BlockStore.Object, this.connectionManager, this.nodeStats, this.nodeLifetime, this.ConsensusSettings, this.dateTimeProvider); this.TestConsensusManager = new TestConsensusManager(consensusManager); }
private async void Button_OnClick(object sender, RoutedEventArgs e) { if (CurrentWork?.Result == ResultCodes.Success) { MainTransitioner.SelectedIndex = 3; Content.SelectedIndex = 2; return; } var NextButton = (Button)sender; if (MainViewModel.Instance.Encoder == null) { MainTransitioner.SelectedIndex = 1; PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast); return; } if (workFetched) { return; } workFetched = true; ButtonProgressAssist.SetIsIndicatorVisible(NextButton, true); ButtonProgressAssist.SetIsIndeterminate(NextButton, true); var work = await Client.GetNextWork(); CurrentWork = work; Student.DataContext = work.Student; ButtonProgressAssist.SetIsIndicatorVisible(NextButton, false); ButtonProgressAssist.SetIsIndeterminate(NextButton, false); //_encoderMagic.IsGenieOut = false; var errorMessage = ""; switch (work.Result) { case ResultCodes.Success: WorkDataGrid.ItemsSource = work.ClassSchedules; //_workMagic.IsGenieOut = true; MainTransitioner.SelectedIndex = 3; Content.SelectedIndex = 2; LoginLamp.Visibility = Visibility.Collapsed; StudentId.Text = work.StudentId; StudentName.Text = work.StudentName; break; case ResultCodes.NotFound: //MessageBox.Show("No more pending items."); errorMessage = "No more requests"; break; case ResultCodes.Offline: errorMessage = "Can not find server"; break; case ResultCodes.Timeout: errorMessage = "Request timeout"; break; case ResultCodes.Error: errorMessage = "Request timeout"; break; } await ShowMessage(errorMessage); workFetched = false; }
public static void RunExample() { Console.WriteLine("Peer Discovery Example ...\n"); Console.WriteLine("Please select mode:"); Console.WriteLine("1 - Server (Discoverable)"); Console.WriteLine("2 - Client (Discovers servers)"); //Read in user choice bool serverMode; if (Console.ReadKey(true).Key == ConsoleKey.D1) { serverMode = true; } else { serverMode = false; } //Both server and client must be discoverable PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast); //Write out the network adaptors that are discoverable Console.WriteLine("\nPeer Identifier: " + NetworkComms.NetworkIdentifier); Console.WriteLine("\nDiscoverable on:"); foreach (IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.UDP)) { Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port); } if (serverMode) { //The server does nothing else now but wait to be discovered. Console.WriteLine("\nPress any key to quit."); ConsoleKeyInfo key = Console.ReadKey(true); } else { while (true) { int selectedOption = 0; Console.WriteLine("\nPlease select the desired option:"); Console.WriteLine("1 - Discover servers asynchronously"); Console.WriteLine("2 - Discover servers synchronously"); Console.WriteLine("3 - Close Client"); while (true) { bool parseSucces = int.TryParse(Console.ReadKey(true).KeyChar.ToString(), out selectedOption); if (parseSucces && selectedOption <= 3 && selectedOption > 0) { break; } Console.WriteLine("Invalid choice. Please try again."); } //Ensure a previous example loop does not duplicate the asynchronous event delegate PeerDiscovery.OnPeerDiscovered -= PeerDiscovered; if (selectedOption == 1) { #region Discover Asynchronously Console.WriteLine("\nDiscovering servers asynchronously ... "); //Append the OnPeerDiscovered event //The PeerDiscovered delegate will just write to the console. PeerDiscovery.OnPeerDiscovered += PeerDiscovered; //Trigger the asynchronous discovery PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast); #endregion } else if (selectedOption == 2) { #region Discover Synchronously Console.WriteLine("\nDiscovering servers synchronously ... "); //Discover peers synchronously //This method allows peers 2 seconds to respond after the request has been sent Dictionary <ShortGuid, Dictionary <ConnectionType, List <EndPoint> > > discoveredPeerEndPoints = PeerDiscovery.DiscoverPeers(PeerDiscovery.DiscoveryMethod.UDPBroadcast); //Write out a list of discovered peers foreach (ShortGuid networkIdentifier in discoveredPeerEndPoints.Keys) { PeerDiscovered(networkIdentifier, discoveredPeerEndPoints[networkIdentifier]); } #endregion } else if (selectedOption == 3) { break; } else { throw new Exception("Unable to determine selected option."); } } } //We should always call shutdown when our application closes. NetworkComms.Shutdown(); }
private void DiscoverPeersTimer_Elapsed(object sender, ElapsedEventArgs e) { PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast); }
/// <summary> /// Creates the test chain with some default blocks and txs. /// </summary> /// <param name="network">Network to create the chain on.</param> /// <param name="scriptPubKey">Public key to create blocks/txs with.</param> /// <returns>Context object representing the test chain.</returns> public static async Task <ITestChainContext> CreateAsync(Network network, Script scriptPubKey, string dataDir) { var nodeSettings = new NodeSettings(network, args: new string[] { $"-datadir={dataDir}" }); ILoggerFactory loggerFactory = nodeSettings.LoggerFactory; IDateTimeProvider dateTimeProvider = DateTimeProvider.Default; network.Consensus.Options = new ConsensusOptions(); network.Consensus.Rules = new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration().GetRules(); var consensusSettings = new ConsensusSettings(nodeSettings); var chain = new ConcurrentChain(network); InMemoryCoinView inMemoryCoinView = new InMemoryCoinView(chain.Tip.HashBlock); var cachedCoinView = new CachedCoinView(inMemoryCoinView, DateTimeProvider.Default, loggerFactory); var networkPeerFactory = new NetworkPeerFactory(network, dateTimeProvider, loggerFactory, new PayloadProvider().DiscoverPayloads(), new SelfEndpointTracker()); var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, new SelfEndpointTracker()); var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, network, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager); var connectionSettings = new ConnectionManagerSettings(nodeSettings); var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, connectionSettings, new VersionProvider()); var blockPuller = new LookaheadBlockPuller(chain, connectionManager, new LoggerFactory()); var peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager); var deployments = new NodeDeployments(network, chain); ConsensusRules consensusRules = new PowConsensusRules(network, loggerFactory, dateTimeProvider, chain, deployments, consensusSettings, new Checkpoints(), inMemoryCoinView, new Mock <ILookaheadBlockPuller>().Object).Register(); var consensusLoop = new ConsensusLoop(new AsyncLoopFactory(loggerFactory), new NodeLifetime(), chain, cachedCoinView, blockPuller, deployments, loggerFactory, new ChainState(new InvalidBlockHashStore(dateTimeProvider)), connectionManager, dateTimeProvider, new Signals.Signals(), consensusSettings, nodeSettings, peerBanning, consensusRules); await consensusLoop.StartAsync(); var blockPolicyEstimator = new BlockPolicyEstimator(new MempoolSettings(nodeSettings), loggerFactory, nodeSettings); var mempool = new TxMempool(dateTimeProvider, blockPolicyEstimator, loggerFactory, nodeSettings); var mempoolLock = new MempoolSchedulerLock(); var minerSettings = new MinerSettings(nodeSettings); // Simple block creation, nothing special yet: PowBlockDefinition blockDefinition = new PowBlockDefinition(consensusLoop, dateTimeProvider, loggerFactory, mempool, mempoolLock, minerSettings, network, consensusRules); BlockTemplate newBlock = blockDefinition.Build(chain.Tip, scriptPubKey); chain.SetTip(newBlock.Block.Header); RuleContext ruleContext = consensusRules.CreateRuleContext(new ValidationContext { Block = newBlock.Block }, consensusLoop.Tip); ruleContext.MinedBlock = true; await consensusLoop.ValidateAndExecuteBlockAsync(ruleContext); List <BlockInfo> blockinfo = CreateBlockInfoList(); // We can't make transactions until we have inputs // Therefore, load 100 blocks :) int baseheight = 0; var blocks = new List <Block>(); var srcTxs = new List <Transaction>(); for (int i = 0; i < blockinfo.Count; ++i) { Block currentBlock = Block.Load(newBlock.Block.ToBytes(network.Consensus.ConsensusFactory), network); currentBlock.Header.HashPrevBlock = chain.Tip.HashBlock; currentBlock.Header.Version = 1; currentBlock.Header.Time = Utils.DateTimeToUnixTime(chain.Tip.GetMedianTimePast()) + 1; Transaction txCoinbase = network.CreateTransaction(currentBlock.Transactions[0].ToBytes()); txCoinbase.Inputs.Clear(); txCoinbase.Version = 1; txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(blockinfo[i].extraNonce), Op.GetPushOp(chain.Height) }))); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this) txCoinbase.AddOutput(new TxOut(Money.Zero, new Script())); currentBlock.Transactions[0] = txCoinbase; if (srcTxs.Count == 0) { baseheight = chain.Height; } if (srcTxs.Count < 4) { srcTxs.Add(currentBlock.Transactions[0]); } currentBlock.UpdateMerkleRoot(); currentBlock.Header.Nonce = blockinfo[i].nonce; chain.SetTip(currentBlock.Header); RuleContext ruleContextForBlock = consensusRules.CreateRuleContext(new ValidationContext { Block = currentBlock }, consensusLoop.Tip); ruleContextForBlock.MinedBlock = true; await consensusLoop.ValidateAndExecuteBlockAsync(ruleContextForBlock); blocks.Add(currentBlock); } // Just to make sure we can still make simple blocks blockDefinition = new PowBlockDefinition(consensusLoop, dateTimeProvider, loggerFactory, mempool, mempoolLock, minerSettings, network, consensusRules); newBlock = blockDefinition.Build(chain.Tip, scriptPubKey); var mempoolValidator = new MempoolValidator(mempool, mempoolLock, dateTimeProvider, new MempoolSettings(nodeSettings), chain, cachedCoinView, loggerFactory, nodeSettings, consensusRules); return(new TestChainContext { MempoolValidator = mempoolValidator, SrcTxs = srcTxs }); }
/// <summary> /// Run example /// </summary> public static void RunExample() { NetworkComms.ConnectionEstablishTimeoutMS = int.MaxValue; SendReceiveOptions nullCompressionSRO = new SendReceiveOptions(DPSManager.GetDataSerializer <ProtobufSerializer>(), null, null); NetworkComms.DefaultSendReceiveOptions = nullCompressionSRO; //We need to define what happens when packets are received. //To do this we add an incoming packet handler for a 'Message' packet type. // //We will define what we want the handler to do inline by using a lambda expression //http://msdn.microsoft.com/en-us/library/bb397687.aspx. //We could also just point the AppendGlobalIncomingPacketHandler method //to a standard method (See AdvancedSend example) // //This handler will convert the incoming raw bytes into a string (this is what //the <string> bit means) and then write that string to the local console window. NetworkComms.AppendGlobalIncomingPacketHandler <string>("Message", (packetHeader, connection, incomingString) => { Console.WriteLine("\n ... Incoming message from " + connection.ToString() + " saying '" + incomingString + "'."); }); //Start listenning BluetoothRadio defaultRadio = BluetoothRadio.PrimaryRadio; defaultRadio.Mode = RadioMode.Discoverable; Connection.StartListening(ConnectionType.Bluetooth, new BluetoothEndPoint(defaultRadio.LocalAddress, ServiceGUID), true); //Print the address we are listening on to make sure everything //worked as expected. Console.WriteLine("Listening for messages on:"); foreach (var localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.Bluetooth)) { Console.WriteLine("{0}", localEndPoint); } PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.BluetoothSDP); //We loop here to allow any number of test messages to be sent and received while (true) { //Request a message to send somewhere Console.WriteLine("\nPlease enter your message and press enter (Type 'exit' to quit):"); string stringToSend = Console.ReadLine(); //If the user has typed exit then we leave our loop and end the example if (stringToSend == "exit") { break; } else { //Once we have a message we need to know where to send it //We have created a small wrapper class to help keep things clean here var endpoints = PeerDiscovery.DiscoverPeers(PeerDiscovery.DiscoveryMethod.BluetoothSDP, 1000); ConnectionInfo targetServerConnectionInfo = new ConnectionInfo(new BluetoothEndPoint(new BluetoothAddress(0xE0B9A5FB552BL), ServiceGUID)); //There are loads of ways of sending data (see AdvancedSend example for more) //but the most simple, which we use here, just uses an IP address (string) and port (integer) //We pull these values out of the ConnectionInfo object we got above and voila! var connection = BluetoothConnection.GetConnection(targetServerConnectionInfo); connection.SendObject("Message", "Hello world"); } } //We should always call shutdown on comms if we have used it NetworkComms.Shutdown(); }
public async Task InitializeAsync() { this.blockinfo = new List <Blockinfo>(); var lst = blockinfoarr.Cast <long>().ToList(); for (int i = 0; i < lst.Count; i += 2) { this.blockinfo.Add(new Blockinfo { extranonce = (int)lst[i], nonce = (uint)lst[i + 1] }); } // Note that by default, these tests run with size accounting enabled. this.network = Network.Main; var hex = Encoders.Hex.DecodeData("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"); this.scriptPubKey = new Script(new[] { Op.GetPushOp(hex), OpcodeType.OP_CHECKSIG }); this.newBlock = new BlockTemplate(this.network); this.entry = new TestMemPoolEntryHelper(); this.chain = new ConcurrentChain(this.network); this.network.Consensus.Options = new PowConsensusOptions(); IDateTimeProvider dateTimeProvider = DateTimeProvider.Default; this.cachedCoinView = new CachedCoinView(new InMemoryCoinView(this.chain.Tip.HashBlock), dateTimeProvider, new LoggerFactory()); var loggerFactory = new ExtendedLoggerFactory(); loggerFactory.AddConsoleWithFilters(); NodeSettings nodeSettings = new NodeSettings(args: new string[] { "-checkpoints" }); var consensusSettings = new ConsensusSettings().Load(nodeSettings); PowConsensusValidator consensusValidator = new PowConsensusValidator(this.network, new Checkpoints(), dateTimeProvider, loggerFactory); NetworkPeerFactory networkPeerFactory = new NetworkPeerFactory(this.network, dateTimeProvider, loggerFactory, new PayloadProvider().DiscoverPayloads(), new SelfEndpointTracker()); var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, new SelfEndpointTracker()); var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, Network.Main, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager); var connectionSettings = new ConnectionManagerSettings(); connectionSettings.Load(nodeSettings); var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, this.network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, connectionSettings); LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(this.chain, connectionManager, new LoggerFactory()); PeerBanning peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager); NodeDeployments deployments = new NodeDeployments(this.network, this.chain); ConsensusRules consensusRules = new PowConsensusRules(this.network, loggerFactory, dateTimeProvider, this.chain, deployments, consensusSettings, new Checkpoints(), this.cachedCoinView, blockPuller).Register(new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration()); this.consensus = new ConsensusLoop(new AsyncLoopFactory(loggerFactory), consensusValidator, new NodeLifetime(), this.chain, this.cachedCoinView, blockPuller, new NodeDeployments(this.network, this.chain), loggerFactory, new ChainState(new InvalidBlockHashStore(dateTimeProvider)), connectionManager, dateTimeProvider, new Signals.Signals(), consensusSettings, nodeSettings, peerBanning, consensusRules); await this.consensus.StartAsync(); this.entry.Fee(11); this.entry.Height(11); var date1 = new MemoryPoolTests.DateTimeProviderSet(); date1.time = dateTimeProvider.GetTime(); date1.timeutc = dateTimeProvider.GetUtcNow(); this.DateTimeProvider = date1; this.mempool = new TxMempool(dateTimeProvider, new BlockPolicyEstimator(new MempoolSettings(nodeSettings), new LoggerFactory(), nodeSettings), new LoggerFactory(), nodeSettings); this.mempoolLock = new MempoolSchedulerLock(); // Simple block creation, nothing special yet: this.newBlock = AssemblerForTest(this).Build(this.chain.Tip, this.scriptPubKey); this.chain.SetTip(this.newBlock.Block.Header); await this.consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext { Block = this.newBlock.Block }, this.network.Consensus, this.consensus.Tip) { CheckPow = false, CheckMerkleRoot = false }); // We can't make transactions until we have inputs // Therefore, load 100 blocks :) this.baseheight = 0; List <Block> blocks = new List <Block>(); this.txFirst = new List <Transaction>(); for (int i = 0; i < this.blockinfo.Count; ++i) { var pblock = this.newBlock.Block.Clone(); // pointer for convenience pblock.Header.HashPrevBlock = this.chain.Tip.HashBlock; pblock.Header.Version = 1; pblock.Header.Time = Utils.DateTimeToUnixTime(this.chain.Tip.GetMedianTimePast()) + 1; Transaction txCoinbase = pblock.Transactions[0].Clone(); txCoinbase.Inputs.Clear(); txCoinbase.Version = 1; txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(this.blockinfo[i].extranonce), Op.GetPushOp(this.chain.Height) }))); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this) txCoinbase.AddOutput(new TxOut(Money.Zero, new Script())); pblock.Transactions[0] = txCoinbase; if (this.txFirst.Count == 0) { this.baseheight = this.chain.Height; } if (this.txFirst.Count < 4) { this.txFirst.Add(pblock.Transactions[0]); } pblock.UpdateMerkleRoot(); pblock.Header.Nonce = this.blockinfo[i].nonce; this.chain.SetTip(pblock.Header); await this.consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext { Block = pblock }, this.network.Consensus, this.consensus.Tip) { CheckPow = false, CheckMerkleRoot = false }); blocks.Add(pblock); } // Just to make sure we can still make simple blocks this.newBlock = AssemblerForTest(this).Build(this.chain.Tip, this.scriptPubKey); Assert.NotNull(this.newBlock); }
public void CanDiscoverAndConnectToPeersOnTheNetwork() { var parameters = new NetworkPeerConnectionParameters(); var testFolder = TestDirectory.Create("CanDiscoverAndConnectToPeersOnTheNetwork"); var nodeSettings = new NodeSettings { DataDir = testFolder.FolderName }; nodeSettings.DataFolder = new DataFolder(nodeSettings); var peerAddressManager = new PeerAddressManager(nodeSettings.DataFolder); var peerAddressManagerBehaviour = new PeerAddressManagerBehaviour(new DateTimeProvider(), peerAddressManager) { PeersToDiscover = 3 }; parameters.TemplateBehaviors.Add(peerAddressManagerBehaviour); var loggerFactory = new ExtendedLoggerFactory(); loggerFactory.AddConsoleWithFilters(); var networkPeerFactory = new NetworkPeerFactory(DateTimeProvider.Default, loggerFactory); var peerConnectorDiscovery = new PeerConnectorDiscovery( new AsyncLoopFactory(loggerFactory), loggerFactory, Network.Main, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager); var peerDiscovery = new PeerDiscovery( new AsyncLoopFactory(loggerFactory), loggerFactory, Network.Main, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager); IConnectionManager connectionManager = new ConnectionManager( new AsyncLoopFactory(loggerFactory), new DateTimeProvider(), loggerFactory, Network.Main, networkPeerFactory, nodeSettings, new NodeLifetime(), parameters, peerAddressManager, new IPeerConnector[] { peerConnectorDiscovery }, peerDiscovery); NetworkPeerConnectionParameters cloned = parameters.Clone(); cloned.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, connectionManager, loggerFactory)); peerDiscovery.DiscoverPeers(cloned); // Wait until we have discovered 3 peers. TestHelper.WaitLoop(() => peerAddressManager.Peers.Count > 3); // Wait until at least one successful connection has been made. while (true) { try { var peerOne = peerAddressManager.SelectPeerToConnectTo(); NetworkPeer node = networkPeerFactory.CreateConnectedNetworkPeer(Network.Main, peerOne, parameters); node.VersionHandshake(); node.Disconnect(); break; } catch { } } ; }