public void Stop() { _update = false; this.SaveResources(); this.StopNodeGroup(); _connectionparameters = null; _wallet = null; }
/// <summary> /// Configure the components of the wallet /// </summary> /// <param name="parameters">The parameters to the connection</param> public void Configure(NodeConnectionParameters parameters) { if (parameters == null) { throw new ArgumentNullException("parameters"); } Configure(new NodesGroup(_Parameters.Network, parameters)); }
public static AddressManager GetAddrman(NodeConnectionParameters parameters) { if (parameters == null) { throw new ArgumentNullException("parameters"); } return(GetAddrman(parameters.TemplateBehaviors)); }
public static void SetAddrman(NodeConnectionParameters parameters, AddressManager addrman) { if (parameters == null) { throw new ArgumentNullException("parameters"); } SetAddrman(parameters.TemplateBehaviors, addrman); }
private NodesGroup CreateNodeGroup(NodeConnectionParameters cloneParameters, NodeServices requiredServices) { return(new NodesGroup(Network, cloneParameters, new NodeRequirement() { MinVersion = this.NodeSettings.ProtocolVersion, RequiredServices = requiredServices, })); }
public ConnectionManager(Network network, NodeConnectionParameters parameters, NodeSettings nodeSettings, ILoggerFactory loggerFactory) { this.network = network; this.nodeSettings = nodeSettings; this.connectionManagerSettings = nodeSettings.ConnectionManager; this.parameters = parameters; this.logger = loggerFactory.CreateLogger(this.GetType().FullName); }
public void Start() { this.logger.LogTrace("()"); this.Parameters.UserAgent = $"{this.NodeSettings.Agent}:{this.GetVersion()}"; this.Parameters.Version = this.NodeSettings.ProtocolVersion; NodeConnectionParameters clonedParameters = this.Parameters.Clone(); clonedParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this, this.loggerFactory)); // Don't start peer discovery if we have specified any nodes using the -connect arg. if (!this.connectionManagerSettings.Connect.Any()) { if (this.Parameters.PeerAddressManagerBehaviour().Mode.HasFlag(PeerAddressManagerBehaviourMode.Discover)) { this.logger.LogInformation("Starting peer discovery..."); this.peerDiscoveryLoop = new PeerDiscoveryLoop(this.asyncLoopFactory, this.Network, clonedParameters, this.nodeLifetime, this.peerAddressManager); this.peerDiscoveryLoop.DiscoverPeers(); } this.DiscoverNodesPeerConnector = this.CreatePeerConnector(clonedParameters, this.discoveredNodeRequiredService, WellKnownPeerConnectorSelectors.ByNetwork, PeerIntroductionType.Discover); } else { // Use if we have specified any nodes using the -connect arg var peers = this.connectionManagerSettings.Connect.Select(node => new NetworkAddress(node)).ToArray(); this.peerAddressManager.AddPeers(peers, IPAddress.Loopback, PeerIntroductionType.Connect); clonedParameters.PeerAddressManagerBehaviour().Mode = PeerAddressManagerBehaviourMode.None; this.ConnectNodePeerConnector = this.CreatePeerConnector(clonedParameters, NodeServices.Nothing, WellKnownPeerConnectorSelectors.ByEndpoint, PeerIntroductionType.Connect, this.connectionManagerSettings.Connect.Count); } { // Use if we have specified any nodes using the -addnode arg var peers = this.connectionManagerSettings.AddNode.Select(node => new NetworkAddress(node)).ToArray(); this.peerAddressManager.AddPeers(peers, IPAddress.Loopback, PeerIntroductionType.Add); clonedParameters.PeerAddressManagerBehaviour().Mode = PeerAddressManagerBehaviourMode.AdvertiseDiscover; this.AddNodePeerConnector = this.CreatePeerConnector(clonedParameters, NodeServices.Nothing, WellKnownPeerConnectorSelectors.ByEndpoint, PeerIntroductionType.Add, this.connectionManagerSettings.AddNode.Count); } // Relate the peer connectors to each other to prevent duplicate connections. var relatedPeerConnectors = new RelatedPeerConnectors(); relatedPeerConnectors.Register("Discovery", this.DiscoverNodesPeerConnector); relatedPeerConnectors.Register("Connect", this.ConnectNodePeerConnector); relatedPeerConnectors.Register("AddNode", this.AddNodePeerConnector); this.DiscoverNodesPeerConnector?.StartConnectAsync(); this.ConnectNodePeerConnector?.StartConnectAsync(); this.AddNodePeerConnector?.StartConnectAsync(); this.StartNodeServer(); this.logger.LogTrace("(-)"); }
public ConnectionManager(Network network, NodeConnectionParameters parameters, NodeSettings nodeSettings, ILoggerFactory loggerFactory, INodeLifetime nodeLifetime) { this.network = network; this.nodeSettings = nodeSettings; this.nodeLifetime = nodeLifetime; this.connectionManagerSettings = nodeSettings.ConnectionManager; this.parameters = parameters; this.parameters.ConnectCancellation = this.nodeLifetime.ApplicationStopping; this.logger = loggerFactory.CreateLogger(this.GetType().FullName); }
public NodeConnectionParameters GetNodeConnectionParameters() { NodeConnectionParameters parameters = new NodeConnectionParameters(); parameters.TemplateBehaviors.FindOrCreate <PingPongBehavior>(); parameters.TemplateBehaviors.Add(new SlimChainBehavior(Chain)); parameters.TemplateBehaviors.Add(new AddressManagerBehavior(AddressManager)); parameters.TemplateBehaviors.Add(new BroadcastHubBehavior()); return(parameters); }
public NodeManager(BlockChain.BlockChain blockChain) { _BlockChain = blockChain; var addressManager = new AddressManager(); _NodeConnectionParameters = new NodeConnectionParameters(); var addressManagerBehavior = new AddressManagerBehavior(addressManager); _NodeConnectionParameters.TemplateBehaviors.Add(addressManagerBehavior); }
public static void ConfigureDefaultNodeConnectionParameters(NodeConnectionParameters parameters) { parameters = parameters ?? new NodeConnectionParameters(); //Optimize for small device parameters.SocketSettings.SendBufferSize = 1024 * 100; parameters.SocketSettings.ReceiveBufferSize = 1024 * 100; parameters.IsRelay = false; parameters.TemplateBehaviors.FindOrCreate <PingPongBehavior>(); //Ping Pong }
public String Start(IPEndPoint IPEndPoint) { // Network network = TestNetwork.Instance; NodeConnectionParameters nodeConnectionParameters = new NodeConnectionParameters(); Node node = Node.Connect(JsonLoader <Network> .Instance.Value, IPEndPoint); node.VersionHandshake(); return(node.IsConnected == true ? "Success" : "Failure"); }
public Node Connect(IPEndPoint endpoint) { NodeConnectionParameters cloneParameters = this.parameters.Clone(); cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this) { OneTry = true }); var node = Node.Connect(this.Network, endpoint, cloneParameters); node.VersionHandshake(); return(node); }
private NodesGroup CreateNodeGroup(NodeConnectionParameters cloneParameters, NodeServices requiredServices) { this.logger.LogTrace("({0}:{1})", nameof(requiredServices), requiredServices); var res = new NodesGroup(this.Network, cloneParameters, new NodeRequirement { MinVersion = this.NodeSettings.ProtocolVersion, RequiredServices = requiredServices, }); this.logger.LogTrace("(-)"); return(res); }
public void CanHandshakeSimple() { WithServerSet(1, servers => { NodeConnectionParameters nodeConnectionParameters = new NodeConnectionParameters(); Node node = Node.Connect(servers[0].Network, servers[0].ExternalEndpoint); Assert.AreEqual(NodeState.Connected, node.State); node.VersionHandshake(); Thread.Sleep(200); //TODO: use reset events instead of sleep }); }
public PeerDiscoveryLoop( IAsyncLoopFactory asyncLoopFactory, Network network, NodeConnectionParameters nodeConnectionParameters, INodeLifetime nodeLifetime, IPeerAddressManager peerAddressManager) { Guard.NotNull(asyncLoopFactory, nameof(asyncLoopFactory)); this.asyncLoopFactory = asyncLoopFactory; this.parameters = nodeConnectionParameters; this.peerAddressManager = peerAddressManager; this.peersToFind = this.parameters.PeerAddressManagerBehaviour().PeersToDiscover; this.network = network; this.nodeLifetime = nodeLifetime; }
private async Task StartConnecting() { await Task.Factory.StartNew(() => { var parameters = new NodeConnectionParameters(); parameters.TemplateBehaviors.Add(new AddressManagerBehavior(GetAddressManager())); parameters.TemplateBehaviors.Add(new ChainBehavior(GetChain())); parameters.TemplateBehaviors.Add(new TrackerBehavior(GetTracker())); if (!_disposed) { _group = new NodesGroup(_settings.Network, parameters, new NodeRequirement() { RequiredServices = NodeServices.Network }); _group.MaximumNodeConnection = 4; _group.Connect(); _connectionParameters = parameters; } }); // PeriodicSave(); _logger.Information("Configuring groups"); _wallet.Configure(_group); if (_isNewWallet) { _logger.Information("New wallet, generating key pool "); //_wallet.GetNextScriptPubKey(); GenerateNewAddress(); SaveWallet(); } _logger.Information("Connecting Wallet"); PeriodicKick(); _wallet.NewWalletTransaction += _wallet_NewWalletTransaction; _wallet.Connect(); _logger.Information("Wallet connected"); _lastHeight = CurrentHeight; //while (!_disposed) //{ // await Task.Delay(10000); // _logger.Information($"Current Height {CurrentHeight}"); // _logger.Information($"Connected Nodes {ConnectedNodes.Count}"); // SaveAsync(); //} }
private async Task InitializeP2pAsync(Network network, EndPoint endPoint) { Guard.NotNull(nameof(network), network); Guard.NotNull(nameof(endPoint), endPoint); using (var handshakeTimeout = new CancellationTokenSource()) { handshakeTimeout.CancelAfter(TimeSpan.FromSeconds(10)); var nodeConnectionParameters = new NodeConnectionParameters() { ConnectCancellation = handshakeTimeout.Token, IsRelay = true }; nodeConnectionParameters.TemplateBehaviors.Add(new TrustedNodeNotifyingBehavior()); var node = await Node.ConnectAsync(network, endPoint, nodeConnectionParameters); // We have to find it, because it's cloned by the node and not perfectly cloned (event handlers cannot be cloned.) TrustedNodeNotifyingBehavior = node.Behaviors.Find <TrustedNodeNotifyingBehavior>(); try { Logger.LogInfo <Node>("TCP Connection succeeded, handshaking..."); node.VersionHandshake(Constants.LocalBackendNodeRequirements, handshakeTimeout.Token); var peerServices = node.PeerVersion.Services; if (!peerServices.HasFlag(NodeServices.Network) && !peerServices.HasFlag(NodeServices.NODE_NETWORK_LIMITED)) { throw new InvalidOperationException("Wasabi cannot use the local node because it does not provide blocks."); } Logger.LogInfo <Node>("Handshake completed successfully."); if (!node.IsConnected) { throw new InvalidOperationException($"Wasabi could not complete the handshake with the local node and dropped the connection.{Environment.NewLine}" + "Probably this is because the node does not support retrieving full blocks or segwit serialization."); } LocalNode = node; } catch (OperationCanceledException) when(handshakeTimeout.IsCancellationRequested) { Logger.LogWarning <Node>($"Wasabi could not complete the handshake with the local node. Probably Wasabi is not whitelisted by the node.{Environment.NewLine}" + "Use \"whitebind\" in the node configuration. (Typically whitebind=127.0.0.1:8333 if Wasabi and the node are on the same machine and whitelist=1.2.3.4 if they are not.)"); throw; } } }
public void CanDiscoverAndConnectToPeersOnTheNetwork() { var parameters = new NodeConnectionParameters(); var testFolder = TestDirectory.Create("CanDiscoverAndConnectToPeersOnTheNetwork"); var nodeSettings = new NodeSettings { DataDir = testFolder.FolderName }; nodeSettings.DataFolder = new DataFolder(nodeSettings); var addressManager = new PeerAddressManager(nodeSettings.DataFolder); var addressManagerBehaviour = new PeerAddressManagerBehaviour(new DateTimeProvider(), addressManager) { PeersToDiscover = 3 }; parameters.TemplateBehaviors.Add(addressManagerBehaviour); var peerDiscoveryLoop = new PeerDiscoveryLoop( new AsyncLoopFactory(new LoggerFactory()), Network.Main, parameters, new NodeLifetime(), addressManager); peerDiscoveryLoop.DiscoverPeers(); //Wait until we have discovered 3 peers while (addressManager.Peers.Count < 3) { Task.Delay(TimeSpans.Second).GetAwaiter().GetResult(); } var peerOne = addressManager.SelectPeerToConnectTo(PeerIntroductionType.Discover); Node node = Node.Connect(Network.Main, peerOne, parameters); node.VersionHandshake(); node.Disconnect(); var peerTwo = addressManager.SelectPeerToConnectTo(PeerIntroductionType.Discover); Node node2 = Node.Connect(Network.Main, peerTwo, parameters); node.Disconnect(); }
/// <inheritdoc /> public override void Start() { this.StartAddressManager(); this.StartChain(); NodeConnectionParameters connectionParameters = this.connectionManager.Parameters; connectionParameters.IsRelay = !this.nodeSettings.ConfigReader.GetOrDefault("blocksonly", false); connectionParameters.TemplateBehaviors.Add(new ChainHeadersBehavior(this.chain, this.chainState)); connectionParameters.TemplateBehaviors.Add(new AddressManagerBehavior(this.addressManager)); connectionParameters.TemplateBehaviors.Add(new TimeSyncBehavior(this.timeSyncBehaviorState, this.dateTimeProvider, this.loggerFactory)); this.disposableResources.Add(this.timeSyncBehaviorState); this.disposableResources.Add(this.chainRepository); this.disposableResources.Add(this.connectionManager); this.disposableResources.Add(this.nodeSettings.LoggerFactory); }
protected Node Connect(NodeServer originServer, NodeServer destServer) { NodeConnectionParameters nodeConnectionParameters = new NodeConnectionParameters(); AddressManager addressManager = new AddressManager(); AddressManagerBehavior addressManagerBehavior = new AddressManagerBehavior(addressManager); nodeConnectionParameters.TemplateBehaviors.Add(addressManagerBehavior); // nodeConnectionParameters.AddressFrom = originServer.ExternalEndpoint; Node node = Node.Connect(destServer.Network, destServer.ExternalEndpoint, nodeConnectionParameters); Assert.AreEqual(NodeState.Connected, node.State); Trace.Information($"\n\nConncted from {originServer.ExternalEndpoint} to {destServer.ExternalEndpoint}\n\n"); return(node); }
public Node Connect(IPEndPoint endpoint) { this.logger.LogTrace("({0}:'{1}')", nameof(endpoint), endpoint); NodeConnectionParameters cloneParameters = this.parameters.Clone(); cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this, this.loggerFactory) { OneTry = true }); Node node = Node.Connect(this.Network, endpoint, cloneParameters); node.VersionHandshake(); this.logger.LogTrace("(-)"); return(node); }
public static Node Handshake(NodeServer originServer, NodeServer destServer, String desc) { NodeConnectionParameters nodeConnectionParameters = new NodeConnectionParameters(); NBitcoin.Protocol.AddressManager addressManager = new NBitcoin.Protocol.AddressManager(); // Console.WriteLine ("Address Manager of Handshaked Node " + desc + " is " + addressManager.GetHashCode ()); AddressManagerBehavior addressManagerBehavior = new AddressManagerBehavior(addressManager); nodeConnectionParameters.TemplateBehaviors.Add(addressManagerBehavior); Node node = Node.Connect(destServer.Network, destServer.ExternalEndpoint, nodeConnectionParameters); node.Advertize = true; node.MyVersion.AddressFrom = originServer.ExternalEndpoint; node.VersionHandshake(); return(node); }
private static NodesGroup CreateGroup(IEnumerable <CoreNode> nodes, int connections) { AddressManagerBehavior behavior = new AddressManagerBehavior(new AddressManager()); foreach (var node in nodes) { behavior.AddressManager.Add(new NetworkAddress(node.Endpoint), IPAddress.Parse("127.0.0.1")); } NodeConnectionParameters parameters = new NodeConnectionParameters(); parameters.TemplateBehaviors.Add(behavior); Wallet.ConfigureDefaultNodeConnectionParameters(parameters); parameters.IsTrusted = true; NodesGroup connected = new NodesGroup(Network.RegTest, parameters); connected.AllowSameGroup = true; connected.MaximumNodeConnection = connections; return(connected); }
private void StartNodeServer() { var logs = new StringBuilder(); logs.AppendLine("Node listening on:"); foreach (NodeServerEndpoint listen in this.connectionManagerSettings.Listen) { NodeConnectionParameters cloneParameters = this.Parameters.Clone(); var server = new NodeServer(this.Network) { LocalEndpoint = listen.Endpoint, ExternalEndpoint = this.connectionManagerSettings.ExternalEndpoint }; this.Servers.Add(server); cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(true, this, this.loggerFactory) { Whitelisted = listen.Whitelisted }); server.InboundNodeConnectionParameters = cloneParameters; try { server.Listen(); } catch (SocketException e) { this.logger.LogCritical("Unable to listen on port {0} (you can change the port using '-port=[number]'). Error message: {1}", listen.Endpoint.Port, e.Message); throw e; } logs.Append(listen.Endpoint.Address + ":" + listen.Endpoint.Port); if (listen.Whitelisted) { logs.Append(" (whitelisted)"); } logs.AppendLine(); } this.logger.LogInformation(logs.ToString()); }
public Server(IPAddress externalAddress, NetworkInfo network, NodeConnectionParameters nodeConnectionParameters) { _Server = new NodeServer(network, internalPort: network.DefaultPort); OwnResource(_Server); if (externalAddress != null) { var externalEndpoint = new IPEndPoint(externalAddress, network.DefaultPort); AddressManager addressManager = AddressManagerBehavior.GetAddrman(nodeConnectionParameters); addressManager.Add(new NetworkAddress(externalEndpoint)); addressManager.Connected(new NetworkAddress(externalEndpoint)); _Server.ExternalEndpoint = externalEndpoint; } _Server.InboundNodeConnectionParameters = nodeConnectionParameters; _Server.AllowLocalPeers = false; //TODO NodeServerTrace.Information($"Server setup at {externalAddress}"); }
/// <summary> /// Starts and manages a connection to multiple peers in the Bitcoin network. /// </summary> public void Connect() { var parameters = new NodeConnectionParameters(); parameters.TemplateBehaviors.Add(new AddressManagerBehavior(GetAddressManager())); parameters.TemplateBehaviors.Add(new ChainBehavior(GetChain())); _peers = new NodesGroup(Network.Main, parameters, new NodeRequirement() { RequiredServices = NodeServices.Network }); _peers.MaximumNodeConnection = 8; _peers.Connect(); _connectionParameters = parameters; PeriodicSave(); PeriodicReconnect(); PeriodicUpdate(); }
public Server(IResourceOwner resourceOwner, IPEndPoint externalEndpoint, NBitcoin.Network network) { _Server = new NodeServer(network, internalPort: externalEndpoint.Port); resourceOwner.OwnResource(_Server); NodeConnectionParameters nodeConnectionParameters = new NodeConnectionParameters(); NBitcoin.Protocol.AddressManager addressManager = AddressManager.Instance.GetBitcoinAddressManager(); // new NBitcoin.Protocol.AddressManager (); var addressManagerBehavior = new AddressManagerBehavior(addressManager); // addressManagerBehavior.Mode = hasExternal ? AddressManagerBehaviorMode.AdvertizeDiscover : AddressManagerBehaviorMode.Discover; nodeConnectionParameters.TemplateBehaviors.Add(addressManagerBehavior); _Server.InboundNodeConnectionParameters = nodeConnectionParameters; _Server.AllowLocalPeers = true; //TODO _Server.ExternalEndpoint = externalEndpoint; Trace.Information($"Server setup at {externalEndpoint}"); }
internal async void StartConnecting() { await Task.Factory.StartNew(() => { var parameters = new NodeConnectionParameters(); parameters.TemplateBehaviors.Add(new AddressManagerBehavior(GetAddressManager())); //So we find nodes faster parameters.TemplateBehaviors.Add(new ChainBehavior(GetChain())); //So we don't have to load the chain each time we start parameters.TemplateBehaviors.Add(new TrackerBehavior(GetTracker())); //Tracker knows which scriptPubKey and outpoints to track, it monitors all your wallets at the same if (!_Disposed) { _Group = new NodesGroup(Network.Main, parameters, new NodeRequirement() { RequiredServices = NodeServices.Network //Needed for SPV }); _Group.MaximumNodeConnection = 4; _Group.Connect(); _ConnectionParameters = parameters; } }); }
public async Task ConnectAsync(CancellationToken cancel) { using var handshakeTimeout = new CancellationTokenSource(); using var linked = CancellationTokenSource.CreateLinkedTokenSource(handshakeTimeout.Token, cancel, Stop.Token); handshakeTimeout.CancelAfter(TimeSpan.FromSeconds(21)); var parameters = new NodeConnectionParameters() { UserAgent = UserAgent, ConnectCancellation = linked.Token, IsRelay = true }; parameters.TemplateBehaviors.Add(new TrustedP2pBehavior(MempoolService)); Node = await Node.ConnectAsync(Network, EndPoint, parameters).ConfigureAwait(false); Node.VersionHandshake(cancel); if (!Node.PeerVersion.Services.HasFlag(NodeServices.Network)) { throw new InvalidOperationException("Wasabi cannot use the local node because it does not provide blocks."); } if (!Node.IsConnected) { throw new InvalidOperationException( $"Could not complete the handshake with the local node and dropped the connection.{Environment.NewLine}" + "Probably this is because the node does not support retrieving full blocks or segwit serialization."); } lock (SubscriptionLock) { TrustedP2pBehavior = Node.Behaviors.Find <TrustedP2pBehavior>(); Node.UncaughtException += Node_UncaughtException; Node.StateChanged += P2pNode_StateChanged; Node.Disconnected += Node_DisconnectedAsync; TrustedP2pBehavior.BlockInv += TrustedP2pBehavior_BlockInv; NodeEventsSubscribed = true; MempoolService.TrustedNodeMode = Node.IsConnected; } }
public static AddressManager GetAddrman(NodeConnectionParameters parameters) { if(parameters == null) throw new ArgumentNullException("parameters"); return GetAddrman(parameters.TemplateBehaviors); }
public static BroadcastHub GetBroadcastHub(NodeConnectionParameters parameters) { return GetBroadcastHub(parameters.TemplateBehaviors); }
public static void SetAddrman(NodeConnectionParameters parameters, AddressManager addrman) { if(parameters == null) throw new ArgumentNullException("parameters"); SetAddrman(parameters.TemplateBehaviors, addrman); }