private async Task <TransactionProcessor> CreateTransactionProcessorAsync([CallerMemberName] string callerName = "")
{
var datadir = EnvironmentHelpers.GetDataDir(Path.Combine("WalletWasabi", "Bench"));
var dir = Path.Combine(datadir, callerName, "TransactionStore");
Console.WriteLine(dir);
await IoHelpers.DeleteRecursivelyWithMagicDustAsync(dir);
// Create the services.
// 1. Create connection service.
var nodes = new NodesGroup(Network.Main);
var bitcoinStore = new BitcoinStore();
var serviceConfiguration = new ServiceConfiguration(2, 2, 21, 50, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 45678), Money.Coins(0.0001m));
// 2. Create wasabi synchronizer service.
var synchronizer = new WasabiSynchronizer(Network.Main, bitcoinStore, () => new Uri("http://localhost:35474"), null);
synchronizer.Start(requestInterval: TimeSpan.FromDays(1), TimeSpan.FromDays(1), 1000);
// 3. Create key manager service.
var keyManager = KeyManager.CreateNew(out _, "password");
// 4. Create chaumian coinjoin client.
var chaumianClient = new CoinJoinClient(synchronizer, Network.Main, keyManager);
// 5. Create wallet service.
await bitcoinStore.InitializeAsync(dir, Network.Main);
var workDir = Path.Combine(datadir, EnvironmentHelpers.GetMethodName());
var feeProviders = new FeeProviders(new[] { synchronizer });
var wallet = new WalletService(bitcoinStore, keyManager, synchronizer, nodes, workDir, serviceConfiguration, feeProviders);
return(wallet.TransactionProcessor);
}
public void RegisterServices(
BitcoinStore bitcoinStore,
WasabiSynchronizer syncer,
NodesGroup nodes,
ServiceConfiguration serviceConfiguration,
IFeeProvider feeProvider,
CoreNode coreNode = null)
{
if (State != WalletState.Uninitialized)
{
throw new InvalidOperationException($"{nameof(State)} must be {WalletState.Uninitialized}. Current state: {State}.");
}
BitcoinStore = Guard.NotNull(nameof(bitcoinStore), bitcoinStore);
Nodes = Guard.NotNull(nameof(nodes), nodes);
Synchronizer = Guard.NotNull(nameof(syncer), syncer);
ServiceConfiguration = Guard.NotNull(nameof(serviceConfiguration), serviceConfiguration);
FeeProvider = Guard.NotNull(nameof(feeProvider), feeProvider);
CoreNode = coreNode;
ChaumianClient = new CoinJoinClient(Synchronizer, Network, KeyManager);
TransactionProcessor = new TransactionProcessor(BitcoinStore.TransactionStore, KeyManager, ServiceConfiguration.DustThreshold, ServiceConfiguration.PrivacyLevelStrong);
Coins = TransactionProcessor.Coins;
TransactionProcessor.WalletRelevantTransactionProcessed += TransactionProcessor_WalletRelevantTransactionProcessedAsync;
ChaumianClient.OnDequeue += ChaumianClient_OnDequeue;
BitcoinStore.IndexStore.NewFilter += IndexDownloader_NewFilterAsync;
BitcoinStore.IndexStore.Reorged += IndexDownloader_ReorgedAsync;
BitcoinStore.MempoolService.TransactionReceived += Mempool_TransactionReceived;
State = WalletState.Initialized;
}
private async Task <bool> StartConnecting()
{
return(await Task <bool> .Factory.StartNew(() =>
{
try
{
NodeConnectionParameters parameters = new NodeConnectionParameters();
//So we find nodes faster
parameters.TemplateBehaviors.Add(new AddressManagerBehavior(GetAddressManager()));
//So we don't have to load the chain each time we start
parameters.TemplateBehaviors.Add(new ChainBehavior(GetChain()));
//Tracker knows which scriptPubKey and outpoints to track
parameters.TemplateBehaviors.Add(new TrackerBehavior(GetTracker()));
var nodeReq = new NodeRequirement()
{
RequiredServices = NodeServices.Network
};
_group = new NodesGroup(_wallet.NetworkChoice, parameters, nodeReq);
_group.MaximumNodeConnection = MAX_NUM_CONNECTIONS;
_group.Connect();
_connectionparameters = parameters;
return true;
}
catch (Exception e)
{
throw e;
}
}));
}
public async Task Connect()
{
await Task.Factory.StartNew(async() =>
{
EndpointInstance = await BusManager.StartServiceBus(Network.Name);
_nodeGroup = new NodesGroup(Network, GetNodeConnectionParameters())
{
AllowSameGroup = true,
};
_nodeGroup.Requirements.SupportSPV = true;
foreach (NetworkAddress networkAddress in BootstrapNodes)
{
AddressManager.Add(networkAddress);
}
_nodeGroup.Connect();
_nodeGroup.ConnectedNodes.Added += (s, e) =>
{
var node = e.Node;
node.MessageReceived += RebroadcastEvent;
node.MessageReceived += (node1, message) =>
{
Console.WriteLine("Message Received");
SaveChainData();
};
node.Disconnected += n =>
{
Console.WriteLine("Disconnected!");
};
};
});
}
public void CanMaintainConnectionToNodes()
{
using (var builder = NodeBuilder.Create())
{
NodesGroup connected = CreateGroup(builder, 2);
connected.Connect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
//Server crash abruptly
builder.Nodes[0].Kill(false);
TestUtils.Eventually(() => connected.ConnectedNodes.Count < 2);
builder.Nodes[0].Start();
//Reconnect ?
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
//Client crash abruptly
connected.ConnectedNodes.First().Disconnect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 1);
//Reconnect ?
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
connected.Disconnect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 0);
}
}
public void CanMaintainConnectionToNodes()
{
using (NodeServerTester servers = new NodeServerTester(Network.TestNet))
{
NodesGroup connected = CreateGroup(servers, 2);
connected.Connect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
//Server crash abruptly
servers.ConnectedNodes.First().Disconnect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 1);
//Reconnect ?
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
//Client crash abruptly
connected.ConnectedNodes.First().Disconnect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 1);
//Reconnect ?
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
connected.Disconnect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 0);
}
}
NodesGroup CreateNodeGroup(ConcurrentChain chain, int startHeight)
{
AddressManager manager = new AddressManager();
manager.Add(new NetworkAddress(NodeEndpoint), IPAddress.Loopback);
NodesGroup group = new NodesGroup(Network, new NodeConnectionParameters()
{
Services = NodeServices.Nothing,
IsRelay = true,
TemplateBehaviors =
{
new AddressManagerBehavior(manager)
{
PeersToDiscover = 1,
Mode = AddressManagerBehaviorMode.None
},
new ExplorerBehavior(this, chain)
{
StartHeight = startHeight
},
new ChainBehavior(chain)
{
CanRespondToGetHeaders = false
}
}
});
group.AllowSameGroup = true;
group.MaximumNodeConnection = 1;
group.Connect();
return(group);
}
private async void StartConnecting()
{
await Task.Factory.StartNew(() =>
{
NodeConnectionParameters parameters = new NodeConnectionParameters();
//So we find nodes faster
parameters.TemplateBehaviors.Add(new AddressManagerBehavior(this.GetAddressManager()));
//So we don't have to load the chain each time we start
parameters.TemplateBehaviors.Add(new ChainBehavior(this.GetChain()));
//Tracker knows which scriptPubKey and outpoints to track
parameters.TemplateBehaviors.Add(new TrackerBehavior(this.GetTracker()));
var nodeReq = new NodeRequirement()
{
RequiredServices = NodeServices.Network
};
_group = new NodesGroup(_wallet.NetworkChoice, parameters, nodeReq);
_group.MaximumNodeConnection = MAX_NUM_CONNECTIONS;
_group.Connect();
_connectionparameters = parameters;
});
_wallet.Configure(_group);
_wallet.Connect();
_wallet.Connected = true;
PeriodicKick();
PeriodicSave();
}
public void CanMaintainConnectionToNodes()
{
using (NodeServerTester servers = new NodeServerTester(Network.TestNet))
{
servers.Server1.InboundNodeConnectionParameters.Services = NodeServices.Network;
AddressManagerBehavior behavior = new AddressManagerBehavior(new AddressManager());
behavior.AddressManager.Add(new NetworkAddress(servers.Server1.ExternalEndpoint), IPAddress.Parse("127.0.0.1"));
NodeConnectionParameters parameters = new NodeConnectionParameters();
parameters.TemplateBehaviors.Add(behavior);
NodesGroup connected = new NodesGroup(Network.TestNet, parameters, new NodeRequirement()
{
RequiredServices = NodeServices.Network
});
connected.AllowSameGroup = true;
connected.MaximumNodeConnection = 2;
connected.Connect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
//Server crash abruptly
servers.Server1.ConnectedNodes.First().Disconnect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 1);
//Reconnect ?
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
//Client crash abruptly
connected.ConnectedNodes.First().Disconnect();
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 1);
//Reconnect ?
TestUtils.Eventually(() => connected.ConnectedNodes.Count == 2);
}
}
private 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(App.Network, parameters, new NodeRequirement()
{
RequiredServices = NodeServices.Network //Needed for SPV
});
_Group.MaximumNodeConnection = 4;
_Group.Connect();
_ConnectionParameters = parameters;
}
});
PeriodicSave();
PeriodicUiUpdate();
PeriodicKick();
foreach (var wallet in Wallets)
{
wallet.Wallet.Configure(_Group);
wallet.Wallet.Connect();
}
}
public WalletService(
BitcoinStore bitcoinStore,
KeyManager keyManager,
WasabiSynchronizer syncer,
CoinJoinClient chaumianClient,
NodesGroup nodes,
string workFolderDir,
ServiceConfiguration serviceConfiguration,
IFeeProvider feeProvider,
CoreNode coreNode = null)
{
BitcoinStore = Guard.NotNull(nameof(bitcoinStore), bitcoinStore);
KeyManager = Guard.NotNull(nameof(keyManager), keyManager);
Nodes = Guard.NotNull(nameof(nodes), nodes);
Synchronizer = Guard.NotNull(nameof(syncer), syncer);
ChaumianClient = Guard.NotNull(nameof(chaumianClient), chaumianClient);
ServiceConfiguration = Guard.NotNull(nameof(serviceConfiguration), serviceConfiguration);
FeeProvider = Guard.NotNull(nameof(feeProvider), feeProvider);
CoreNode = coreNode;
HandleFiltersLock = new AsyncLock();
BlocksFolderPath = Path.Combine(workFolderDir, "Blocks", Network.ToString());
RuntimeParams.SetDataDir(workFolderDir);
BlockFolderLock = new AsyncLock();
KeyManager.AssertCleanKeysIndexed();
KeyManager.AssertLockedInternalKeysIndexed(14);
TransactionProcessor = new TransactionProcessor(BitcoinStore.TransactionStore, KeyManager, ServiceConfiguration.DustThreshold, ServiceConfiguration.PrivacyLevelStrong);
Coins = TransactionProcessor.Coins;
TransactionProcessor.WalletRelevantTransactionProcessed += TransactionProcessor_WalletRelevantTransactionProcessedAsync;
if (Directory.Exists(BlocksFolderPath))
{
if (Synchronizer.Network == Network.RegTest)
{
Directory.Delete(BlocksFolderPath, true);
Directory.CreateDirectory(BlocksFolderPath);
}
}
else
{
Directory.CreateDirectory(BlocksFolderPath);
}
var walletName = "UnnamedWallet";
if (!string.IsNullOrWhiteSpace(KeyManager.FilePath))
{
walletName = Path.GetFileNameWithoutExtension(KeyManager.FilePath);
}
BitcoinStore.IndexStore.NewFilter += IndexDownloader_NewFilterAsync;
BitcoinStore.IndexStore.Reorged += IndexDownloader_ReorgedAsync;
BitcoinStore.MempoolService.TransactionReceived += Mempool_TransactionReceived;
}
private void StopNodeGroup()
{
if (_group != null)
{
_group.Dispose();
}
_group = null;
}
public void StartNodeListener(int startHeight)
{
_Nodes = CreateNodeGroup(Chain, startHeight);
while (_Nodes.ConnectedNodes.Count == 0)
{
Thread.Sleep(10);
}
}
public P2pBlockProvider(NodesGroup nodes, CoreNode?coreNode, HttpClientFactory httpClientFactory, ServiceConfiguration serviceConfiguration, Network network)
{
Nodes = nodes;
CoreNode = coreNode;
HttpClientFactory = httpClientFactory;
ServiceConfiguration = serviceConfiguration;
Network = network;
}
public P2pBlockProvider(NodesGroup nodes, CoreNode coreNode, WasabiSynchronizer syncer, ServiceConfiguration serviceConfiguration, Network network)
{
Nodes = nodes;
CoreNode = coreNode;
Synchronizer = syncer;
ServiceConfiguration = serviceConfiguration;
Network = network;
}
public Wallet(
Network network,
BitcoinStore bitcoinStore,
KeyManager keyManager,
WasabiSynchronizer syncer,
NodesGroup nodes,
string workFolderDir,
ServiceConfiguration serviceConfiguration,
IFeeProvider feeProvider,
CoreNode coreNode = null)
{
Network = Guard.NotNull(nameof(network), network);
BitcoinStore = Guard.NotNull(nameof(bitcoinStore), bitcoinStore);
KeyManager = Guard.NotNull(nameof(keyManager), keyManager);
Nodes = Guard.NotNull(nameof(nodes), nodes);
Synchronizer = Guard.NotNull(nameof(syncer), syncer);
ServiceConfiguration = Guard.NotNull(nameof(serviceConfiguration), serviceConfiguration);
FeeProvider = Guard.NotNull(nameof(feeProvider), feeProvider);
CoreNode = coreNode;
ChaumianClient = new CoinJoinClient(Synchronizer, Network, keyManager);
HandleFiltersLock = new AsyncLock();
BlocksFolderPath = Path.Combine(workFolderDir, "Blocks", Network.ToString());
RuntimeParams.SetDataDir(workFolderDir);
BlockFolderLock = new AsyncLock();
KeyManager.AssertCleanKeysIndexed();
KeyManager.AssertLockedInternalKeysIndexed(14);
TransactionProcessor = new TransactionProcessor(BitcoinStore.TransactionStore, KeyManager, ServiceConfiguration.DustThreshold, ServiceConfiguration.PrivacyLevelStrong);
Coins = TransactionProcessor.Coins;
TransactionProcessor.WalletRelevantTransactionProcessed += TransactionProcessor_WalletRelevantTransactionProcessedAsync;
ChaumianClient.OnDequeue += ChaumianClient_OnDequeue;
if (Directory.Exists(BlocksFolderPath))
{
if (Network == Network.RegTest)
{
Directory.Delete(BlocksFolderPath, true);
Directory.CreateDirectory(BlocksFolderPath);
}
}
else
{
Directory.CreateDirectory(BlocksFolderPath);
}
BitcoinStore.IndexStore.NewFilter += IndexDownloader_NewFilterAsync;
BitcoinStore.IndexStore.Reorged += IndexDownloader_ReorgedAsync;
BitcoinStore.MempoolService.TransactionReceived += Mempool_TransactionReceived;
State = WalletState.Initialized;
}
public void Dispose()
{
_Disposed = true;
_Starting.Wait();
if (_Group != null)
{
_Group.Disconnect();
_Group = null;
}
}
/// <summary>
/// Configure the components of the wallet
/// </summary>
/// <param name="group">The group to use</param>
public void Configure(NodesGroup group)
{
if (group == null)
{
throw new ArgumentNullException("group");
}
var 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);
}
var wallet = FindWalletBehavior(parameters.TemplateBehaviors);
if (wallet == null)
{
wallet = new WalletBehavior(this);
parameters.TemplateBehaviors.Add(wallet);
}
_Group = group;
if (_ListenedTracker != null)
{
_ListenedTracker.NewOperation -= _ListenerTracked_NewOperation;
}
_ListenedTracker = tracker.Tracker;
_ListenedTracker.NewOperation += _ListenerTracked_NewOperation;
}
void AttachedNode_StateChanged(Node node, NodeState oldState)
{
ListenerTrace.Info("State change " + node.State);
if (node.State == NodeState.HandShaked)
{
ListenerTrace.Info("Node handshaked");
AttachedNode.MessageReceived += _Listener.node_MessageReceived;
AttachedNode.Disconnected += AttachedNode_Disconnected;
ListenerTrace.Info("Connection count : " + NodesGroup.GetNodeGroup(node).ConnectedNodes.Count);
}
}
public NodeConnectionService(Context context, ILoggerFactory loggerFactory) : base(context)
{
this.NodesGroup = new NodesGroup(this.Context.Network);
this.logger = loggerFactory.CreateLogger <NodeConnectionService>();
// some config settings
this.NodesGroup.MaximumNodeConnection = this.Context.Config.MaximumNodeConnection;
// set the connection parameters
this.NodesGroup.NodeConnectionParameters = this.Context.ConnectionParameters;
}
private async Task LoadGroup()
{
AddressManager manager = new AddressManager();
manager.Add(new NetworkAddress(_ChainConfiguration.NodeEndpoint), IPAddress.Loopback);
NodesGroup group = new NodesGroup(_Network.NBitcoinNetwork, new NodeConnectionParameters()
{
Services = NodeServices.Nothing,
IsRelay = true,
TemplateBehaviors =
{
new AddressManagerBehavior(manager)
{
PeersToDiscover = 1,
Mode = AddressManagerBehaviorMode.None
},
new ExplorerBehavior(_Repository, _Chain, _AddressPoolService, _EventAggregator)
{
StartHeight = _ChainConfiguration.StartHeight
},
new SlimChainBehavior(_Chain),
new PingPongBehavior()
}
});
group.AllowSameGroup = true;
group.MaximumNodeConnection = 1;
var task = WaitConnected(group);
group.Connect();
try
{
await task;
}
catch (Exception ex)
{
Logs.Configuration.LogError(ex, $"{_Network.CryptoCode}: Failure to connect to the bitcoin node (P2P)");
throw;
}
_Group = group;
group.ConnectedNodes.Added += ConnectedNodes_Changed;
group.ConnectedNodes.Removed += ConnectedNodes_Changed;
// !Hack. ExplorerBehavior.AttachCore is async and calling the repository.
// Because the repository is single thread, calling a ping make sure that AttachCore
// has fully ran.
// Without this hack, NBXplorer takes sometimes 1 min to go from Synching to Ready state
await _Repository.Ping();
}
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);
}
private async Task LoadGroup()
{
AddressManager manager = new AddressManager();
manager.Add(new NetworkAddress(GetEndpoint()), IPAddress.Loopback);
NodesGroup group = new NodesGroup(_Network.NBitcoinNetwork, new NodeConnectionParameters()
{
Services = NodeServices.Nothing,
IsRelay = true,
TemplateBehaviors =
{
new AddressManagerBehavior(manager)
{
PeersToDiscover = 1,
Mode = AddressManagerBehaviorMode.None
},
new ExplorerBehavior(_Repository, _Chain, _EventAggregator)
{
StartHeight = _Configuration.ChainConfigurations.First(c => c.CryptoCode == _Network.CryptoCode).StartHeight
},
new ChainBehavior(_Chain)
{
CanRespondToGetHeaders = false,
SkipPoWCheck = true,
StripHeader = true
},
new PingPongBehavior()
}
});
group.AllowSameGroup = true;
group.MaximumNodeConnection = 1;
var task = WaitConnected(group);
group.Connect();
try
{
await task;
}
catch (Exception ex)
{
Logs.Configuration.LogError(ex, $"{_Network.CryptoCode}: Failure to connect to the bitcoin node (P2P)");
throw;
}
_Group = group;
group.ConnectedNodes.Added += ConnectedNodes_Changed;
group.ConnectedNodes.Removed += ConnectedNodes_Changed;
}
public void Dispose()
{
lock (l)
{
if (_Nodes != null)
{
_Nodes.Disconnect();
_Nodes = null;
}
if (Repository != null)
{
Repository.Dispose();
Repository = null;
}
}
}
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();
//}
}
public Task StopAsync(CancellationToken cancellationToken)
{
_Disposed = true;
_Cts.Cancel();
_Subscription.Dispose();
if (_Group != null)
{
_Group.ConnectedNodes.Added -= ConnectedNodes_Changed;
_Group.ConnectedNodes.Removed -= ConnectedNodes_Changed;
_Group.Disconnect();
_Group = null;
}
State = BitcoinDWaiterState.NotStarted;
_Chain = null;
_Tick.Set();
return(_Loop);
}
private static async Task WaitConnected(NodesGroup group)
{
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>();
EventHandler <NodeEventArgs> waitingConnected = null;
waitingConnected = (a, b) =>
{
tcs.TrySetResult(true);
group.ConnectedNodes.Added -= waitingConnected;
};
group.ConnectedNodes.Added += waitingConnected;
CancellationTokenSource cts = new CancellationTokenSource(5000);
using (cts.Token.Register(() => tcs.TrySetCanceled()))
{
await tcs.Task;
}
}
public void AddDiscoveredNodesRequirement(NodeServices services)
{
this.discoveredNodeRequiredService |= services;
NodesGroup group = this.DiscoveredNodeGroup;
if (group != null &&
!group.Requirements.RequiredServices.HasFlag(services))
{
group.Requirements.RequiredServices |= NodeServices.NODE_WITNESS;
foreach (Node node in group.ConnectedNodes)
{
if (!node.PeerVersion.Services.HasFlag(services))
{
node.DisconnectAsync("The peer does not support the required services requirement");
}
}
}
}
private void SaveGroupInfo(UniGraph graphData)
{
graphData.nodeGroups.Clear();
foreach (var groupView in groupViews)
{
var groupData = groupView.group;
var groupInfo = new NodesGroup()
{
color = groupData.color,
position = groupData.position,
size = groupData.size,
title = groupData.title,
nodeIds = GetNodesIdsByGuid(groupData.innerNodeGUIDs),
};
graphData.nodeGroups.Add(groupInfo);
}
}
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);
}
public NodesGroupBehavior(NodesGroup parent)
{
_Parent = parent;
}
