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