// public TestNetwork Network { get; private set; }
//public int SeedServerIndex {
// set {
// Network.AddSeed (new NetworkAddress(nodeServers [value].ExternalEndpoint));
// }
//}
public TesterNodeServerSet(int count)
{
// Network = new TestNetwork ();
for (int i = 0; i < count; i++)
{
int port = 3380 + i;
int internalPort = port;
NodeServer Server = new NodeServer(JsonLoader <Network> .Instance.Value, internalPort: internalPort);
Server.NodeAdded += (NodeServer sender, Node node) => {
LogMessageContext.Create("Node added to test server");
};
NodeConnectionParameters nodeConnectionParameters = new NodeConnectionParameters();
NBitcoin.Protocol.AddressManager addressManager = new NBitcoin.Protocol.AddressManager();
nodeConnectionParameters.TemplateBehaviors.Add(new AddressManagerBehavior(addressManager));
Server.InboundNodeConnectionParameters = nodeConnectionParameters;
Server.AllowLocalPeers = true;
Server.ExternalEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1").MapToIPv6Ex(), port);
Server.Listen();
nodeServers.Add(Server);
}
}
public static void SendTransaction(Transaction tx)
{
AddressManager nodeParams = new AddressManager();
IPEndPoint endPoint = TranslateHostNameToIP("http://btcnode.placefullcloud.com", 8333);
nodeParams.Add(new NetworkAddress(endPoint), endPoint.Address);
using (var node = Node.Connect(Network, nodeParams))
{
node.VersionHandshake();
node.SendMessage(new InvPayload(InventoryType.MSG_TX, tx.GetHash()));
node.SendMessage(new TxPayload(tx));
}
}
public AddressManager()
{
if (File.Exists(addressManagerFile))
{
addressManager = NBitcoin.Protocol.AddressManager.LoadPeerFile(addressManagerFile);
// LogMessageContext.Create ("Loaded " + Count() + " address(es)");
}
else
{
addressManager = new NBitcoin.Protocol.AddressManager();
// addressManager.SavePeerFile (addressManagerFile, network);
// LogMessageContext.Create ("Created");
}
}
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);
}
public void CanSerializeDeserializePeerTable()
{
AddressManager addrman = new AddressManager();
addrman.SavePeerFile("CanSerializeDeserializePeerTable.dat", Network.Main);
AddressManager.LoadPeerFile("CanSerializeDeserializePeerTable.dat", Network.Main);
addrman = AddressManager.LoadPeerFile("../../data/peers.dat", Network.Main);
addrman.DebugMode = true;
addrman.Check();
addrman.SavePeerFile("serializerPeer.dat", Network.Main);
AddressManager addrman2 = AddressManager.LoadPeerFile("serializerPeer.dat", Network.Main);
addrman2.DebugMode = true;
addrman2.Check();
addrman2.SavePeerFile("serializerPeer2.dat", Network.Main);
var original = File.ReadAllBytes("serializerPeer2.dat");
var after = File.ReadAllBytes("serializerPeer.dat");
Assert.True(original.SequenceEqual(after));
}
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}");
}
private void StartCore()
{
LogMessageContext.Create("Starting...");
using (var Servers = new TesterNodeServerSet(3)) {
Node node1 = Handshake(Servers [0], Servers [1], "node1");
Node node2 = Handshake(Servers [1], Servers [2], "node2");
NBitcoin.Protocol.AddressManager addressManager = new NBitcoin.Protocol.AddressManager();
addressManager.PeersToFind = 4;
NodeConnectionParameters parameters = new NodeConnectionParameters();
parameters.TemplateBehaviors.Add(new AddressManagerBehavior(addressManager));
// Servers.SeedServerIndex = 2; //TODO
NodesGroup nodesGroup = new NodesGroup(JsonLoader <Network> .Instance.Value, parameters);
nodesGroup.AllowSameGroup = true; //TODO
nodesGroup.MaximumNodeConnection = 2; //TODO
nodesGroup.Connect();
Thread.Sleep(20000); //TODO
Console.ForegroundColor = ConsoleColor.Blue;
LogMessageContext.Create("Found nodes: " + nodesGroup.ConnectedNodes.Count);
foreach (Node node in nodesGroup.ConnectedNodes)
{
LogMessageContext.Create("Found node: " + node.RemoteSocketAddress + " " + node.RemoteSocketPort);
}
LogMessageContext.Create("Stopping");
}
}
public void CanUseAddrManager()
{
AddressManager addrman = new AddressManager();
addrman.DebugMode = true;
var localhost = new NetworkAddress(IPAddress.Parse("127.0.0.1"), 8333);
addrman.Add(localhost, localhost.Endpoint.Address);
Assert.NotNull(addrman.nKey);
Assert.True(addrman.nKey != new uint256(0));
Assert.True(addrman.nNew == 1);
addrman.Good(localhost);
Assert.True(addrman.nNew == 0);
Assert.True(addrman.nTried == 1);
addrman.Attempt(localhost);
var addr = addrman.Select();
Assert.False(addr.Ago < TimeSpan.FromSeconds(10.0));
addrman.Connected(localhost);
addr = addrman.Select();
Assert.True(addr.Ago < TimeSpan.FromSeconds(10.0));
}
public static AddressManager LoadPeerFile(string filePath, Network expectedNetwork = null)
{
var addrman = new AddressManager();
byte[] data, hash;
using(var fs = File.Open(filePath, FileMode.Open, FileAccess.Read))
{
data = new byte[fs.Length - 32];
fs.Read(data, 0, data.Length);
hash = new byte[32];
fs.Read(hash, 0, 32);
}
var actual = Hashes.Hash256(data);
var expected = new uint256(hash);
if(expected != actual)
throw new FormatException("Invalid address manager file");
BitcoinStream stream = new BitcoinStream(data);
stream.Type = SerializationType.Disk;
uint magic = 0;
stream.ReadWrite(ref magic);
if(expectedNetwork != null && expectedNetwork.Magic != magic)
{
throw new FormatException("This file is not for the expected network");
}
addrman.ReadWrite(stream);
return addrman;
}
public void CanStressAddrManager()
{
Exception exception = null;
var addrmanager = new AddressManager();
Random randl = new Random();
for(int i = 0 ; i < 30 ; i++)
{
NetworkAddress address = RandomNetworkAddress(randl);
IPAddress addressSource = RandomAddress(randl);
address.Ago = TimeSpan.FromMinutes(5.0);
addrmanager.Add(address, addressSource);
}
addrmanager.DebugMode = true;
var threads =
Enumerable
.Range(0, 20)
.Select(t => new Thread(() =>
{
try
{
Random rand = new Random(t);
for(int i = 0 ; i < 50 ; i++)
{
NetworkAddress address = RandomNetworkAddress(rand);
IPAddress addressSource = RandomAddress(rand);
var operation = rand.Next(0, 7);
switch(operation)
{
case 0:
addrmanager.Attempt(address);
break;
case 1:
addrmanager.Add(address, addressSource);
break;
case 2:
addrmanager.Select();
break;
case 3:
addrmanager.GetAddr();
break;
case 4:
{
var several = addrmanager.GetAddr();
addrmanager.Good(several.Length == 0 ? address : several[0]);
}
break;
case 5:
addrmanager.Connected(address);
break;
case 6:
addrmanager.ToBytes();
break;
default:
throw new NotSupportedException();
}
}
}
catch(Exception ex)
{
exception = ex;
throw;
}
})).ToArray();
foreach(var t in threads)
t.Start();
foreach(var t in threads)
t.Join();
Assert.True(addrmanager.nNew != 0);
Assert.True(addrmanager.nTried != 0);
Assert.True(addrmanager.GetAddr().Length != 0);
Assert.Null(exception);
}
/// <summary>
/// Configure the components of the wallet
/// </summary>
/// <param name="chain">The chain to keep in sync, if not provided the whole chain will be downloaded on the network (more than 30MB)</param>
/// <param name="addrman">The Address Manager for speeding up peer discovery</param>
/// <param name="tracker">The tracker responsible for providing bloom filters</param>
public void Configure(ConcurrentChain chain = null,
AddressManager addrman = null,
Tracker tracker = null)
{
if(State != WalletState.Created)
throw new InvalidOperationException("The wallet is already connecting or connected");
var parameters = new NodeConnectionParameters();
ConfigureDefaultNodeConnectionParameters(parameters);
//Pick the behaviors
if(addrman != null)
parameters.TemplateBehaviors.Add(new AddressManagerBehavior(addrman)); //Listen addr, help for node discovery
if(chain != null)
parameters.TemplateBehaviors.Add(new ChainBehavior(chain)); //Keep chain in sync
if(tracker != null)
parameters.TemplateBehaviors.Add(new TrackerBehavior(tracker, chain)); //Set bloom filters and scan the blockchain
Configure(parameters);
}
/// <summary>
/// Connect to a random node on the network
/// </summary>
/// <param name="network">The network to connect to</param>
/// <param name="addrman">The addrman used for finding peers</param>
/// <param name="parameters">The parameters used by the found node</param>
/// <param name="connectedAddresses">The already connected addresses, the new address will be select outside of existing groups</param>
/// <returns></returns>
public static Node Connect(NetworkInfo network, AddressManager addrman, NodeConnectionParameters parameters = null, IPAddress[] connectedAddresses = null)
{
parameters = parameters ?? new NodeConnectionParameters();
AddressManagerBehavior.SetAddrman(parameters, addrman);
return(Connect(network, parameters, connectedAddresses));
}
/// <summary>
/// Connect the wallet with the given connection parameters
/// </summary>
/// <param name="parameters"></param>
public void Connect(NodeConnectionParameters parameters)
{
if(State != WalletState.Created)
throw new InvalidOperationException("The wallet is already connecting or connected");
var group = NodesGroup.GetNodeGroup(parameters);
if(group == null)
{
group = new NodesGroup(_Parameters.Network, parameters);
}
parameters = group.NodeConnectionParameters;
group.Requirements.MinVersion = ProtocolVersion.PROTOCOL_VERSION;
group.Requirements.RequiredServices = NodeServices.Network;
var chain = parameters.TemplateBehaviors.Find<ChainBehavior>();
if(chain == null)
{
chain = new ChainBehavior(new ConcurrentChain(_Parameters.Network));
parameters.TemplateBehaviors.Add(chain);
}
if(chain.Chain.Genesis.HashBlock != _Parameters.Network.GetGenesis().GetHash())
throw new InvalidOperationException("ChainBehavior with invalid network chain detected");
var addrman = parameters.TemplateBehaviors.Find<AddressManagerBehavior>();
if(addrman == null)
{
addrman = new AddressManagerBehavior(new AddressManager());
parameters.TemplateBehaviors.Add(addrman);
}
var tracker = parameters.TemplateBehaviors.Find<TrackerBehavior>();
if(tracker == null)
{
tracker = new TrackerBehavior(new Tracker(), chain.Chain);
parameters.TemplateBehaviors.Add(tracker);
}
_Chain = chain.Chain;
_AddressManager = addrman.AddressManager;
_Tracker = tracker.Tracker;
_TrackerBehavior = tracker;
_Group = group;
if(AddKnownScriptToTracker())
_Group.Purge("Bloom filter renew");
_State = WalletState.Disconnected;
_Group.Connect();
_Group.ConnectedNodes.Added += ConnectedNodes_Added;
_Group.ConnectedNodes.Removed += ConnectedNodes_Added;
foreach(var node in _Group.ConnectedNodes)
{
node.Behaviors.Find<TrackerBehavior>().Scan(_ScanLocation, Created);
}
}
