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);
}
