public void StoreTest()
{
ConfigStore store = CreateConfigStore();
AddressManager mgr = new AddressManager(store);
ConfigStore actual = mgr.Store;
Assert.Equal(mgr.Store, actual);
}
public ContactInfoService(IOrderManager orderManager, IReferenceManagement referenceManagement)
{
if (orderManager == null) throw new ArgumentNullException("orderManager");
_orderManager = orderManager;
_addressManager = new AddressManager(referenceManagement);
}
public DVSUserManagementService(IUsersManagement userManager, IReferenceManagement referenceManager, IDVSUserManager dvsUserManager)
{
_userManager = userManager;
_referenceManager = referenceManager;
_dvsUserManager = dvsUserManager;
_addressManager = new AddressManager(referenceManager);
}
public ConfigStore(string connectString, TimeSpan timeout)
{
if (string.IsNullOrEmpty(connectString))
{
throw new ArgumentException("connectString");
}
if (timeout.Ticks <= 0)
{
throw new ArgumentException("timeout");
}
m_timeout = timeout;
m_connectString = connectString;
m_domains = new DomainManager(this);
m_addresses = new AddressManager(this);
m_certificates = new CertificateManager(this);
m_anchors = new AnchorManager(this);
m_dnsRecords = new DnsRecordManager(this);
m_administrators = new AdministratorManager(this);
m_properties = new PropertyManager(this);
m_blobs = new NamedBlobManager(this);
m_Mdns = new MdnManager(this);
m_bundles = new BundleManager(this);
m_certPolicies = new CertPolicyManager(this, new CertPolicyParseValidator());
m_certPolicyGroups = new CertPolicyGroupManager(this);
}
public static void SetAddrman(NodeBehaviorsCollection behaviors, AddressManager addrman)
{
if (behaviors == null) throw new ArgumentNullException("behaviors");
var behavior = behaviors.Find<AddressManagerBehavior>();
if(behavior == null)
{
// FIXME: Please take a look at this
behavior = new AddressManagerBehavior(addrman);
behaviors.Add(behavior);
}
behavior.AddressManager = addrman;
}
public AppraisalCompanyService(IAppraisalCompanyManagement appraisalCompanyManagement,
IAppraiserManagement appraisalCompanyAdminManagement,
IFeeManager feeManager,
StatusHistoryManager statusHistoryManager,
IReferenceManagement referenceManagement,
ICryptographicProvider cryptographicProvider,
IGeocodingDataService geocodingService)
{
_appraisalCompanyManagement = appraisalCompanyManagement;
_appraisalCompanyAdminManagement = appraisalCompanyAdminManagement;
_feeManager = feeManager;
_referenceManagement = referenceManagement;
_cryptographicProvider = cryptographicProvider;
_addressManager = new AddressManager(referenceManagement);
_phoneManager = new PhoneManager();
_statusHistoryManager = statusHistoryManager;
_geocodingDataService = geocodingService;
}
public OrderManager(IOrderRepository orderRepository,
IClientUserRepository clientUserRepository,
IReferenceManagement referenceManagement,
IAppraiserManagement appraiserManagement,
IConfigurationHelper configurationHelper,
IAppraiserOrderRepository appraiserOrderRepository,
IChangeTrackingRepository changeTrackingRepository,
IOrderHistoryManager orderHistoryManager,
IOrderDocumentsRepository orderDocumentsRepository
)
{
_orderRepository = ValidationUtil.CheckOnNullAndThrowIfNull(orderRepository);
_clientUserRepository = ValidationUtil.CheckOnNullAndThrowIfNull(clientUserRepository);
_referenceManagement = ValidationUtil.CheckOnNullAndThrowIfNull(referenceManagement);
_appraiserManagement = ValidationUtil.CheckOnNullAndThrowIfNull(appraiserManagement);
_configurationHelper = ValidationUtil.CheckOnNullAndThrowIfNull(configurationHelper);
_appraiserOrderRepository = ValidationUtil.CheckOnNullAndThrowIfNull(appraiserOrderRepository);
_addressManager = new AddressManager(_referenceManagement);
_changeTrackingRepository = ValidationUtil.CheckOnNullAndThrowIfNull(changeTrackingRepository);
_orderHistoryManager = ValidationUtil.CheckOnNullAndThrowIfNull(orderHistoryManager);
_orderDocumentsRepository = ValidationUtil.CheckOnNullAndThrowIfNull(orderDocumentsRepository);
}
public OrderService(IOrderRepository orderRepository,
IReferenceManagement referenceManagement,
IGeocodingDataService geocodingDataService, ITaskManager taskManager, IOrderManager orderManager,
IAppraisalFormsService appFormsService, IClientDashboardService dashboarService, IConfigurationHelper configurationHelper,
ICryptographicProvider cryptographicProvider, IDocumentService documentService, IReportManager reportManager, ISecurityContext securityContext,
IOrderDocumentsRepository orderDocumentsRepository)
{
_orderRepository = ValidationUtil.CheckOnNullAndThrowIfNull(orderRepository);
_referenceManager = ValidationUtil.CheckOnNullAndThrowIfNull(referenceManagement);
_geocodingDataService = ValidationUtil.CheckOnNullAndThrowIfNull(geocodingDataService);
_taskManager = ValidationUtil.CheckOnNullAndThrowIfNull(taskManager);
_orderManager = ValidationUtil.CheckOnNullAndThrowIfNull(orderManager);
_appFormsService = ValidationUtil.CheckOnNullAndThrowIfNull(appFormsService);
_dashboarService = ValidationUtil.CheckOnNullAndThrowIfNull(dashboarService);
_configurationHelper = ValidationUtil.CheckOnNullAndThrowIfNull(configurationHelper);
_cryptographicProvider = ValidationUtil.CheckOnNullAndThrowIfNull(cryptographicProvider);
_documentService = ValidationUtil.CheckOnNullAndThrowIfNull(documentService);
_reportManager = ValidationUtil.CheckOnNullAndThrowIfNull(reportManager);
_securityContext = ValidationUtil.CheckOnNullAndThrowIfNull(securityContext);
_orderDocumentsRepository = ValidationUtil.CheckOnNullAndThrowIfNull(orderDocumentsRepository);
_addressManager = new AddressManager(_referenceManager);
_dateTimeManager = new DateTimeManager(_referenceManager);
}
public void CanDiscoverPeers()
{
int SERVER_COUNT = 4;
int FIRST_SERVER = 0;
int SECOND_SERVER = 1;
int LAST_SERVER = 2;
int NEW_SERVER = 3;
var ToBeConnected = new List <NodeServer>();
var ToBeDiscovered = new List <Node>();
WithServerSet(SERVER_COUNT, servers =>
{
servers.SeedServerIndex = LAST_SERVER; //TODO
ToBeConnected.Add(servers[FIRST_SERVER]);
ToBeConnected.Add(servers[SECOND_SERVER]);
ToBeConnected.Add(servers[LAST_SERVER]);
ToBeDiscovered.Add(Handshake(servers[FIRST_SERVER], servers[SECOND_SERVER]));
Trace.Information("Handshake First -> Second");
ToBeDiscovered.Add(Handshake(servers[SECOND_SERVER], servers[LAST_SERVER]));
Trace.Information("Handshake Second -> Last");
#region Setup Parameters for NodeGroup
AddressManager addressManager = new AddressManager();
addressManager.PeersToFind = ToBeConnected.Count * 2; // nodes answer to GetAddr with random nodes, so keep trying until we get all expected items
NodeConnectionParameters parameters = new NodeConnectionParameters();
parameters.TemplateBehaviors.Add(new AddressManagerBehavior(addressManager));
parameters.AddressFrom = servers[NEW_SERVER].ExternalEndpoint; //TODO
NodesGroup nodesGroup = new NodesGroup(servers.Network, parameters);
nodesGroup.AllowSameGroup = true; //TODO
nodesGroup.MaximumNodeConnection = ToBeConnected.Count; //TODO
#endregion
nodesGroup.Connect();
AutoResetEvent waitForDiscoveredAll = new AutoResetEvent(false);
var discoveredAll = false;
nodesGroup.ConnectedNodes.Added += (object sender, NodeEventArgs e) =>
{
Console.WriteLine($"\n\n\nPeer found: {e.Node.Peer.Endpoint}\n\n\n");
Node node = ToBeDiscovered.Find(n => n.MyVersion.AddressFrom.Equals(e.Node.Peer.Endpoint));
if (node != null && ToBeDiscovered.Contains(node))
{
ToBeDiscovered.Remove(node);
if (ToBeDiscovered.Count == 0)
{
discoveredAll = true;
waitForDiscoveredAll.Set();
}
}
};
Assert.True(waitForDiscoveredAll.WaitOne(30000));
Assert.True(discoveredAll);
});
}
private void BroadcastTransaction(Action <BroadcastHub> actionSender, Action actionReceiver)
{
WithServerSet(2, servers =>
{
WithBlockChains(2, null, blockChains =>
{
AutoResetEvent waitForConnection = new AutoResetEvent(false);
bool connected = false;
servers.SeedServerIndex = 0;
AddressManager serverAddressManager = new AddressManager();
serverAddressManager.Add(
new NetworkAddress(servers[0].ExternalEndpoint),
servers[0].ExternalEndpoint.Address
);
serverAddressManager.Connected(new NetworkAddress(servers[0].ExternalEndpoint));
NodeConnectionParameters serverParameters = new NodeConnectionParameters();
serverParameters.TemplateBehaviors.Add(new AddressManagerBehavior(serverAddressManager));
serverParameters.TemplateBehaviors.Add(new BroadcastHubBehavior());
serverParameters.TemplateBehaviors.Add(new SPVBehavior(blockChains[0], BroadcastHub.GetBroadcastHub(serverParameters.TemplateBehaviors)));
blockChains[0].OnAddedToMempool += transaction => {
Trace.Information("-- Transaction Received (node server)");
actionReceiver();
};
servers[0].InboundNodeConnectionParameters = serverParameters;
#region NodeGroup
AddressManager addressManager = new AddressManager();
addressManager.PeersToFind = 1;
NodeConnectionParameters nodesGroupParameters = new NodeConnectionParameters();
nodesGroupParameters.AddressFrom = servers[1].ExternalEndpoint;
nodesGroupParameters.TemplateBehaviors.Add(new AddressManagerBehavior(addressManager));
nodesGroupParameters.TemplateBehaviors.Add(new BroadcastHubBehavior());
nodesGroupParameters.TemplateBehaviors.Add(new SPVBehavior(blockChains[1], BroadcastHub.GetBroadcastHub(nodesGroupParameters.TemplateBehaviors)));
blockChains[1].OnAddedToMempool += transaction =>
{
Trace.Information("-- Transaction Received (node group)");
};
NodesGroup nodesGroup = new NodesGroup(servers.Network, nodesGroupParameters);
nodesGroup.AllowSameGroup = true;
nodesGroup.MaximumNodeConnection = 1;
nodesGroup.ConnectedNodes.Added += (object sender, NodeEventArgs e) =>
{
Trace.Information("-- Node added to node group");
connected = true;
waitForConnection.Set();
};
nodesGroup.Connect();
#endregion
Assert.True(waitForConnection.WaitOne(10000)); //TODO: use reset events instead of sleep
Assert.True(connected);
actionSender(BroadcastHub.GetBroadcastHub(nodesGroup.NodeConnectionParameters));
Trace.Information("-- Done");
});
});
}
public async Task TestServicesAsync(string networkString)
{
await RuntimeParams.LoadAsync();
var network = Network.GetNetwork(networkString);
var blocksToDownload = new List <uint256>();
if (network == Network.Main)
{
blocksToDownload.Add(new uint256("00000000000000000037c2de35bd85f3e57f14ddd741ce6cee5b28e51473d5d0"));
blocksToDownload.Add(new uint256("000000000000000000115315a43cb0cdfc4ea54a0e92bed127f4e395e718d8f9"));
blocksToDownload.Add(new uint256("00000000000000000011b5b042ad0522b69aae36f7de796f563c895714bbd629"));
}
else if (network == Network.TestNet)
{
blocksToDownload.Add(new uint256("0000000097a664c4084b49faa6fd4417055cb8e5aac480abc31ddc57a8208524"));
blocksToDownload.Add(new uint256("000000009ed5b82259ecd2aa4cd1f119db8da7a70e7ea78d9c9f603e01f93bcc"));
blocksToDownload.Add(new uint256("00000000e6da8c2da304e9f5ad99c079df2c3803b49efded3061ecaf206ddc66"));
}
else
{
throw new NotSupportedNetworkException(network);
}
var dataDir = Path.Combine(Global.Instance.DataDir, EnvironmentHelpers.GetCallerFileName());
BitcoinStore bitcoinStore = new BitcoinStore();
await bitcoinStore.InitializeAsync(Path.Combine(dataDir, EnvironmentHelpers.GetMethodName()), network);
var addressManagerFolderPath = Path.Combine(dataDir, "AddressManager");
var addressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{network}.dat");
var blocksFolderPath = Path.Combine(dataDir, "Blocks", network.ToString());
var connectionParameters = new NodeConnectionParameters();
AddressManager addressManager = null;
try
{
addressManager = await NBitcoinHelpers.LoadAddressManagerFromPeerFileAsync(addressManagerFilePath);
Logger.LogInfo($"Loaded {nameof(AddressManager)} from `{addressManagerFilePath}`.");
}
catch (DirectoryNotFoundException)
{
addressManager = new AddressManager();
}
catch (FileNotFoundException)
{
addressManager = new AddressManager();
}
catch (OverflowException)
{
File.Delete(addressManagerFilePath);
addressManager = new AddressManager();
}
catch (FormatException)
{
File.Delete(addressManagerFilePath);
addressManager = new AddressManager();
}
connectionParameters.TemplateBehaviors.Add(new AddressManagerBehavior(addressManager));
connectionParameters.TemplateBehaviors.Add(bitcoinStore.CreateUntrustedP2pBehavior());
using var nodes = new NodesGroup(network, connectionParameters, requirements: Constants.NodeRequirements);
KeyManager keyManager = KeyManager.CreateNew(out _, "password");
WasabiSynchronizer syncer = new WasabiSynchronizer(network, bitcoinStore, new Uri("http://localhost:12345"), Global.Instance.TorSocks5Endpoint);
ServiceConfiguration serviceConfig = new ServiceConfiguration(50, 2, 21, 50, new IPEndPoint(IPAddress.Loopback, network.DefaultPort), Money.Coins(Constants.DefaultDustThreshold));
CachedBlockProvider blockProvider = new CachedBlockProvider(
new P2pBlockProvider(nodes, null, syncer, serviceConfig, network),
new FileSystemBlockRepository(blocksFolderPath, network));
using Wallet wallet = Wallet.CreateAndRegisterServices(
network,
bitcoinStore,
keyManager,
syncer,
nodes,
dataDir,
new ServiceConfiguration(50, 2, 21, 50, new IPEndPoint(IPAddress.Loopback, network.DefaultPort), Money.Coins(Constants.DefaultDustThreshold)),
syncer,
blockProvider);
Assert.True(Directory.Exists(blocksFolderPath));
try
{
var mempoolTransactionAwaiter = new EventsAwaiter <SmartTransaction>(
h => bitcoinStore.MempoolService.TransactionReceived += h,
h => bitcoinStore.MempoolService.TransactionReceived -= h,
3);
var nodeConnectionAwaiter = new EventsAwaiter <NodeEventArgs>(
h => nodes.ConnectedNodes.Added += h,
h => nodes.ConnectedNodes.Added -= h,
3);
nodes.Connect();
var downloadTasks = new List <Task <Block> >();
using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(4));
foreach (var hash in blocksToDownload)
{
downloadTasks.Add(blockProvider.GetBlockAsync(hash, cts.Token));
}
await nodeConnectionAwaiter.WaitAsync(TimeSpan.FromMinutes(3));
var i = 0;
var hashArray = blocksToDownload.ToArray();
foreach (var block in await Task.WhenAll(downloadTasks))
{
Assert.True(File.Exists(Path.Combine(blocksFolderPath, hashArray[i].ToString())));
i++;
}
await mempoolTransactionAwaiter.WaitAsync(TimeSpan.FromMinutes(1));
}
finally
{
// So next test will download the block.
foreach (var hash in blocksToDownload)
{
await blockProvider.BlockRepository.RemoveAsync(hash, CancellationToken.None);
}
if (wallet is { })
public AddressManagerBehavior(AddressManager manager)
{
if(manager == null)
throw new ArgumentNullException("manager");
_AddressManager = manager;
}
public static void SetAddrman(Node node, AddressManager addrman)
{
if(node == null)
throw new ArgumentNullException("node");
SetAddrman(node.Behaviors, addrman);
}
/// <summary>
/// Adds a new address to be used for this order but does not save it to the database until the order is completed
/// to prevent unused records from being added.
/// </summary>
protected void AddOrderBtn_Click(object sender, EventArgs e)
{
try
{
string addressLine1, addressLine2, city, zipOrPostcode, countyStateProvince, country;
bool addOrder = true;
long vehicleAvailableID, locationID, addressID;
DateTime hireStart, hireEnd;
CustomerManager customer = null;
AddressManager address;
addressLine1 = addressLine1Txt.Text;
addressLine2 = addressLine2Txt.Text;
if (Variables.CheckAlphaNumericCharacters(cityTxt.Text) && cityTxt.Text != "")
{
city = cityTxt.Text;
}
else
{
city = "";
addOrder = false;
inputErrorLbl.Text = inputErrorLbl.Text + "<br />" + "Please enter a valid city.";
}
if (Variables.CheckAlphaNumericCharacters(zipOrPostcodeTxt.Text) == true && zipOrPostcodeTxt.Text != "")
{
zipOrPostcode = zipOrPostcodeTxt.Text;
}
else
{
zipOrPostcode = "";
addOrder = false;
inputErrorLbl.Text = inputErrorLbl.Text + "<br />" + "Invalid zip or postcode.";
}
countyStateProvince = countyStateProvinceTxt.Text;
country = Variables.GetCountryByCode(Request["countryDdl"]);
if (country == "")
{
addOrder = false;
inputErrorLbl.Text = inputErrorLbl.Text + "<br />" + "Please enter a country.";
}
AddressValid addressSuccess = GetAddress(false);
if (addressSuccess.addOrder == true && addOrder == true)
{
vehicleAvailableID = Convert.ToInt32(Request.QueryString["VehicleAvailableID"]);
locationID = Convert.ToInt32(Request.QueryString["LocationID"]);
hireStart = Convert.ToDateTime(Request.QueryString["StartDateTime"]);
hireEnd = Convert.ToDateTime(Request.QueryString["EndDateTime"]);
//AddressManager.AddNewAddress(1, addressSuccess.addressLine1, addressSuccess.addressLine2, addressSuccess.city
// , addressSuccess.zipOrPostcode, addressSuccess.countyStateProvince, addressSuccess.country);
if (customersInCompanyDdl.SelectedValue != "")
{
if (Session["LoggedInType"].ToString() == "Customer")
{
customer = CustomerManager.GetCustomers().Where(x => x.UserName.Equals(Session["UserName"].ToString(), StringComparison.OrdinalIgnoreCase)).SingleOrDefault();
}
else if (Session["LoggedInType"].ToString() == "Company")
{
CompanyManager company;
company = CompanyManager.GetCompanies().Where(x => x.UserName.Equals(Session["UserName"].ToString(), StringComparison.OrdinalIgnoreCase)).SingleOrDefault();
customer = CustomerManager.GetCustomers().Where(x => x.CustomerID.ToString() == customersInCompanyDdl.SelectedValue.Split(',')[0]).SingleOrDefault();
}
if (addressSuccess.existingAddress == null)
{
addressID = AddressManager.GetLastAddedAddress();
address = new AddressManager(addressID + 1, 1, addressSuccess.addressLine1, addressSuccess.addressLine2, addressSuccess.city
, addressSuccess.zipOrPostcode, addressSuccess.countyStateProvince, addressSuccess.country);
}
else
{
address = addressSuccess.existingAddress;
}
StoreSessionVariables(address, vehicleAvailableID, locationID, hireStart, hireEnd, customer.CustomerID, false);
Response.Redirect("~/ReviewOrder", false);
orderCreatedLbl.Text = "Order Created";
}
else
{
inputErrorLbl.Text = "Please select a customer to book for";
}
}
}
catch (Exception ex)
{
generalErrorLbl.Text = "An error has occured saying: " + ex.Message + " Please contact your system administrator.";
}
}
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);
}
private static long Dispose = 0; // To detect redundant calls
public static async Task DisposeAsync()
{
var compareRes = Interlocked.CompareExchange(ref Dispose, 1, 0);
if (compareRes == 1)
{
while (Interlocked.Read(ref Dispose) != 2)
{
await Task.Delay(50);
}
return;
}
else if (compareRes == 2)
{
return;
}
try
{
await DisposeInWalletDependentServicesAsync();
if (RpcServer != null)
{
RpcServer.Stop();
Logger.LogInfo($"{nameof(RpcServer)} is stopped.", nameof(Global));
}
if (UpdateChecker != null)
{
await UpdateChecker?.StopAsync();
Logger.LogInfo($"{nameof(UpdateChecker)} is stopped.", nameof(Global));
}
if (Synchronizer != null)
{
await Synchronizer?.StopAsync();
Logger.LogInfo($"{nameof(Synchronizer)} is stopped.", nameof(Global));
}
if (AddressManagerFilePath != null)
{
IoHelpers.EnsureContainingDirectoryExists(AddressManagerFilePath);
if (AddressManager != null)
{
AddressManager?.SavePeerFile(AddressManagerFilePath, Config.Network);
Logger.LogInfo($"{nameof(AddressManager)} is saved to `{AddressManagerFilePath}`.", nameof(Global));
}
}
if (Nodes != null)
{
Nodes?.Disconnect();
while (Nodes.ConnectedNodes.Any(x => x.IsConnected))
{
await Task.Delay(50);
}
Nodes?.Dispose();
Logger.LogInfo($"{nameof(Nodes)} are disposed.", nameof(Global));
}
if (RegTestMemPoolServingNode != null)
{
RegTestMemPoolServingNode.Disconnect();
Logger.LogInfo($"{nameof(RegTestMemPoolServingNode)} is disposed.", nameof(Global));
}
if (TorManager != null)
{
await TorManager?.StopAsync();
Logger.LogInfo($"{nameof(TorManager)} is stopped.", nameof(Global));
}
if (AsyncMutex.IsAny)
{
try
{
await AsyncMutex.WaitForAllMutexToCloseAsync();
Logger.LogInfo($"{nameof(AsyncMutex)}(es) are stopped.", nameof(Global));
}
catch (Exception ex)
{
Logger.LogError($"Error during stopping {nameof(AsyncMutex)}: {ex}", nameof(Global));
}
}
}
catch (Exception ex)
{
Logger.LogWarning(ex, nameof(Global));
}
finally
{
Interlocked.Exchange(ref Dispose, 2);
}
}
public void Listen(ConcurrentChain chain = null)
{
ListenerTrace.Info($"Connecting to node {_Configuration.Indexer.Node}");
var ip = Utils.ParseIpEndpoint(_Configuration.Indexer.Node, Configuration.Indexer.Network.DefaultPort);
ListenerTrace.Info($"Connecting to node ip {ip.ToString()}");
var node = Node.Connect(Configuration.Indexer.Network, ip);
ListenerTrace.Info($"Connected, trying handshake...");
node.VersionHandshake();
ListenerTrace.Info($"Hanshaked");
node.Disconnect();
_Chain = new ConcurrentChain(_Configuration.Indexer.Network);
_Indexer = Configuration.Indexer.CreateIndexer();
if (chain == null)
{
chain = new ConcurrentChain(_Configuration.Indexer.Network);
}
_Chain = chain;
ListenerTrace.Info("Fetching headers from " + _Chain.Tip.Height + " (from azure)");
var client = Configuration.Indexer.CreateIndexerClient();
client.SynchronizeChain(chain);
ListenerTrace.Info("Headers fetched tip " + _Chain.Tip.Height);
_Disposables.Add(_IndexerScheduler = new CustomThreadPoolTaskScheduler(50, 100, "Indexing Threads"));
_Indexer.TaskScheduler = _IndexerScheduler;
_Group = new NodesGroup(Configuration.Indexer.Network);
_Disposables.Add(_Group);
_Group.AllowSameGroup = true;
_Group.MaximumNodeConnection = 2;
AddressManager addrman = new AddressManager();
addrman.Add(new NetworkAddress(ip), IPAddress.Parse("127.0.0.1"));
_Group.NodeConnectionParameters.TemplateBehaviors.Add(new AddressManagerBehavior(addrman)
{
Mode = AddressManagerBehaviorMode.None
});
_Group.NodeConnectionParameters.TemplateBehaviors.Add(new ChainBehavior(_Chain)
{
SkipPoWCheck = true
});
_Group.NodeConnectionParameters.TemplateBehaviors.Add(new Behavior(this));
ListenerTrace.Info("Fetching wallet rules...");
_Wallets = _Configuration.Indexer.CreateIndexerClient().GetAllWalletRules();
ListenerTrace.Info("Wallet rules fetched");
ListenerTrace.Info("Fetching wallet subscriptions...");
_Subscriptions = new SubscriptionCollection(_Configuration.GetSubscriptionsTable().Read());
ListenerTrace.Info("Subscriptions fetched");
_Group.Connect();
ListenerTrace.Info("Fetching transactions to broadcast...");
_Disposables.Add(
Configuration
.Topics
.BroadcastedTransactions
.CreateConsumer("listener", true)
.EnsureSubscriptionExists()
.OnMessage((tx, ctl) =>
{
uint256 hash = null;
var repo = Configuration.Indexer.CreateIndexerClient();
var rejects = Configuration.GetRejectTable();
try
{
hash = tx.Transaction.GetHash();
var indexedTx = repo.GetTransaction(hash);
ListenerTrace.Info("Broadcasting " + hash);
var reject = rejects.ReadOne(hash.ToString());
if (reject != null)
{
ListenerTrace.Info("Abort broadcasting of rejected");
return;
}
if (_Broadcasting.Count > 1000)
{
_Broadcasting.Clear();
}
_Broadcasting.TryAdd(hash, tx.Transaction);
if (indexedTx == null || !indexedTx.BlockIds.Any(id => Chain.Contains(id)))
{
var unused = SendMessageAsync(tx.Transaction);
}
var reschedule = new[]
{
TimeSpan.FromMinutes(5),
TimeSpan.FromMinutes(10),
TimeSpan.FromHours(1),
TimeSpan.FromHours(6),
TimeSpan.FromHours(24),
};
if (tx.Tried <= reschedule.Length - 1)
{
ctl.RescheduleIn(reschedule[tx.Tried]);
tx.Tried++;
}
}
catch (Exception ex)
{
if (!_Disposed)
{
LastException = ex;
ListenerTrace.Error("Error for new broadcasted transaction " + hash, ex);
throw;
}
}
}));
ListenerTrace.Info("Transactions to broadcast fetched");
_Disposables.Add(_Configuration
.Topics
.SubscriptionChanges
.EnsureSubscriptionExists()
.AddUnhandledExceptionHandler(ExceptionOnMessagePump)
.OnMessage(c =>
{
using (_SubscriptionSlimLock.LockWrite())
{
if (c.Added)
{
_Subscriptions.Add(c.Subscription);
}
else
{
_Subscriptions.Remove(c.Subscription.Id);
}
}
}));
_Disposables.Add(_Configuration
.Topics
.SendNotifications
.AddUnhandledExceptionHandler(ExceptionOnMessagePump)
.OnMessageAsync((n, act) =>
{
return(SendAsync(n, act).ContinueWith(t =>
{
if (!_Disposed)
{
if (t.Exception != null)
{
LastException = t.Exception;
}
}
}));
}, new OnMessageOptions()
{
MaxConcurrentCalls = 1000,
AutoComplete = true,
AutoRenewTimeout = TimeSpan.Zero
}));
_Disposables.Add(Configuration
.Topics
.AddedAddresses
.CreateConsumer("updater", true)
.EnsureSubscriptionExists()
.AddUnhandledExceptionHandler(ExceptionOnMessagePump)
.OnMessage(evt =>
{
if (evt == null)
{
return;
}
ListenerTrace.Info("New wallet rule");
using (_WalletsSlimLock.LockWrite())
{
foreach (var address in evt)
{
_Wallets.Add(address.CreateWalletRuleEntry());
}
}
}));
}
public void Start()
{
this.logger.LogTrace("()");
this.parameters.UserAgent = $"{this.NodeSettings.Agent}:{this.GetVersion()}";
this.parameters.Version = this.NodeSettings.ProtocolVersion;
if (this.connectionManagerSettings.Connect.Count == 0)
{
NodeConnectionParameters cloneParameters = this.parameters.Clone();
cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this, this.loggerFactory));
this.DiscoveredNodeGroup = CreateNodeGroup(cloneParameters, this.discoveredNodeRequiredService);
this.DiscoveredNodeGroup.CustomGroupSelector = WellKnownGroupSelectors.ByNetwork; // It is the default, but I want to use it.
}
else
{
NodeConnectionParameters cloneParameters = this.parameters.Clone();
cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this, this.loggerFactory));
cloneParameters.TemplateBehaviors.Remove <AddressManagerBehavior>();
var addrman = new AddressManager();
addrman.Add(this.connectionManagerSettings.Connect.Select(c => new NetworkAddress(c)).ToArray(), IPAddress.Loopback);
var addrmanBehavior = new AddressManagerBehavior(addrman)
{
PeersToDiscover = 10
};
addrmanBehavior.Mode = AddressManagerBehaviorMode.None;
cloneParameters.TemplateBehaviors.Add(addrmanBehavior);
this.ConnectNodeGroup = CreateNodeGroup(cloneParameters, NodeServices.Nothing);
this.ConnectNodeGroup.MaximumNodeConnection = this.connectionManagerSettings.Connect.Count;
this.ConnectNodeGroup.CustomGroupSelector = WellKnownGroupSelectors.ByEndpoint;
}
{
NodeConnectionParameters cloneParameters = this.parameters.Clone();
cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this, this.loggerFactory));
cloneParameters.TemplateBehaviors.Remove <AddressManagerBehavior>();
var addrman = new AddressManager();
addrman.Add(this.connectionManagerSettings.AddNode.Select(c => new NetworkAddress(c)).ToArray(), IPAddress.Loopback);
var addrmanBehavior = new AddressManagerBehavior(addrman)
{
PeersToDiscover = 10
};
addrmanBehavior.Mode = AddressManagerBehaviorMode.AdvertizeDiscover;
cloneParameters.TemplateBehaviors.Add(addrmanBehavior);
this.AddNodeNodeGroup = CreateNodeGroup(cloneParameters, NodeServices.Nothing);
this.AddNodeNodeGroup.MaximumNodeConnection = this.connectionManagerSettings.AddNode.Count;
this.AddNodeNodeGroup.CustomGroupSelector = WellKnownGroupSelectors.ByEndpoint;
}
// Related the groups to each other to prevent duplicate connections.
RelatedNodesGroups relGroups = new RelatedNodesGroups();
relGroups.Register("Discovered", this.DiscoveredNodeGroup);
relGroups.Register("Connect", this.ConnectNodeGroup);
relGroups.Register("AddNode", this.AddNodeNodeGroup);
this.DiscoveredNodeGroup?.Connect();
this.ConnectNodeGroup?.Connect();
this.AddNodeNodeGroup?.Connect();
StringBuilder 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;
server.Listen();
logs.Append(listen.Endpoint.Address + ":" + listen.Endpoint.Port);
if (listen.Whitelisted)
{
logs.Append(" (whitelisted)");
}
logs.AppendLine();
}
this.logger.LogInformation(logs.ToString());
this.logger.LogTrace("(-)");
}
public static void Initialize(Config config)
{
WalletService = null;
ChaumianClient = null;
Config = Guard.NotNull(nameof(config), config);
string blindingPubKeyFile = Path.Combine(DataDir, $"BlindingPubKey{Network}.json");
if (File.Exists(blindingPubKeyFile))
{
string blindingPubKeyJson = "";
blindingPubKeyJson = File.ReadAllText(blindingPubKeyFile);
BlindingPubKey = BlindingRsaPubKey.CreateFromJson(blindingPubKeyJson);
}
else
{
if (Network == Network.Main)
{
BlindingPubKey = new BlindingRsaPubKey(new BigInteger("16421152619146079007287475569112871971988560541093277613438316709041030720662622782033859387192362542996510605015506477964793447620206674394713753349543444988246276357919473682408472170521463339860947351211455351029147665615454176157348164935212551240942809518428851690991984017733153078846480521091423447691527000770982623947706172997649440619968085147635776736938871139581019988225202983052255684151711253254086264386774936200194229277914886876824852466823571396538091430866082004097086602287294474304344865162932126041736158327600847754258634325228417149098062181558798532036659383679712667027126535424484318399849"), new BigInteger("65537"));
}
else
{
BlindingPubKey = new BlindingRsaPubKey(new BigInteger("19473594448380717274202325076521698699373476167359253614775896809797414915031772455344343455269320444157176520539924715307970060890094127521516100754263825112231545354422893125394219335109864514907655429499954825469485252969706079992227103439161156022844535556626007277544637236136559868400854764962522288139619969507311597914908752685925185380735570791798593290356424409633800092336087046668579610273133131498947353719917407262847070395909920415822288443947309434039008038907229064999576278651443575362470457496666718250346530518268694562965606704838796709743032825816642704620776596590683042135764246115456630753521"), new BigInteger("65537"));
}
Directory.CreateDirectory(DataDir);
File.WriteAllText(blindingPubKeyFile, BlindingPubKey.ToJson());
}
var addressManagerFolderPath = Path.Combine(DataDir, "AddressManager");
AddressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{Network}.dat");
var blocksFolderPath = Path.Combine(DataDir, $"Blocks{Network}");
var connectionParameters = new NodeConnectionParameters();
AddressManager = null;
try
{
AddressManager = AddressManager.LoadPeerFile(AddressManagerFilePath);
Logger.LogInfo <AddressManager>($"Loaded {nameof(AddressManager)} from `{AddressManagerFilePath}`.");
}
catch (DirectoryNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (FileNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
connectionParameters.TemplateBehaviors.Add(new AddressManagerBehavior(AddressManager));
MemPoolService = new MemPoolService();
connectionParameters.TemplateBehaviors.Add(new MemPoolBehavior(MemPoolService));
Nodes = new NodesGroup(Network, connectionParameters,
new NodeRequirement
{
RequiredServices = NodeServices.Network,
MinVersion = Constants.ProtocolVersion_WITNESS_VERSION
});
var indexFilePath = Path.Combine(DataDir, $"Index{Network}.dat");
IndexDownloader = new IndexDownloader(Network, indexFilePath, Config.GetCurrentBackendUri());
Nodes.Connect();
Logger.LogInfo("Start connecting to nodes...");
IndexDownloader.Synchronize(requestInterval: TimeSpan.FromSeconds(21));
Logger.LogInfo("Start synchronizing filters...");
}
private Vivina.Erp.DataClasses.Address LoadPostalCode(string postalCode)
{
Vivina.Erp.DataClasses.Address address = null;
if (!String.IsNullOrEmpty(postalCode))
{
var manager = new AddressManager(this);
address = manager.GetAddress(postalCode.Replace("-", ""));
if (address != null)
{
txtNeighborhood.Text = address.Neighborhood;
txtCity.Text = address.City;
txtAddress.Text = address.Name;
cboStates.SelectedValue = address.StateId;
ViewState["NeighborhoodId"] = address.NeighborhoodId;
ViewState["CityId"] = address.CityId;
ViewState["StateId"] = address.StateId;
ViewState["addressExists"] = true;
}
}
else
{
ViewState["addressExists"] = false;
txtNeighborhood.Text = String.Empty;
txtCity.Text = String.Empty;
txtAddress.Text = String.Empty;
txtNumber.Text = String.Empty;
cboStates.ClearSelection();
}
EnableValidators(true);
return address;
}
protected void Page_Load(object sender, EventArgs e)
{
//
// Save the Address
//
if (IsPostBack && !ScriptManager.GetCurrent(Page).IsInAsyncPostBack &&
!String.IsNullOrEmpty(txtAddress.Text) && !String.IsNullOrEmpty(txtPostalCode.Text))
{
var manager = new AddressManager(this);
City city = manager.SaveCity(txtCity.Text.ToUpper(), cboStates.SelectedValue);
Neighborhood neighborhood = manager.SaveNeighborhood(txtNeighborhood.Text.ToUpper(), city.CityId);
manager.SaveAddress(PostalCode, txtAddress.Text.ToUpper(), neighborhood.NeighborhoodId);
}
if (ScriptManager.GetCurrent(Page) != null)
ScriptManager.GetCurrent(Page).Scripts.Add(new ScriptReference("~/App_shared/address/address.ascx.js"));
//btnCorreios.Visible = btnGoogle.Visible = Page.User.IsAuthenticated;
lblTitle.Text = FieldsetTitle;
// btnGoogle.Attributes["onclick"] = "top.InfoControl.Address.ShowMap('" + txtPostalCode.ClientID + "');";
if (!Required)
addressPanel.Style.Add("display", "none");
EnableValidators(Required);
}
public AddressLogic(TestContext context)
{
Address_Manager = new AddressManager(context);
}
public async Task TestServicesAsync(string networkString)
{
var network = Network.GetNetwork(networkString);
var blocksToDownload = new HashSet <uint256>();
if (network == Network.Main)
{
blocksToDownload.Add(new uint256("00000000000000000037c2de35bd85f3e57f14ddd741ce6cee5b28e51473d5d0"));
blocksToDownload.Add(new uint256("000000000000000000115315a43cb0cdfc4ea54a0e92bed127f4e395e718d8f9"));
blocksToDownload.Add(new uint256("00000000000000000011b5b042ad0522b69aae36f7de796f563c895714bbd629"));
}
else if (network == Network.TestNet)
{
blocksToDownload.Add(new uint256("0000000097a664c4084b49faa6fd4417055cb8e5aac480abc31ddc57a8208524"));
blocksToDownload.Add(new uint256("000000009ed5b82259ecd2aa4cd1f119db8da7a70e7ea78d9c9f603e01f93bcc"));
blocksToDownload.Add(new uint256("00000000e6da8c2da304e9f5ad99c079df2c3803b49efded3061ecaf206ddc66"));
}
else
{
throw new NotSupportedException(network.ToString());
}
var addressManagerFolderPath = Path.Combine(Global.Instance.DataDir, "AddressManager");
var addressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{network}.dat");
var blocksFolderPath = Path.Combine(Global.Instance.DataDir, "Blocks", network.ToString());
var connectionParameters = new NodeConnectionParameters();
AddressManager addressManager = null;
try
{
addressManager = AddressManager.LoadPeerFile(addressManagerFilePath);
Logger.LogInfo <AddressManager>($"Loaded {nameof(AddressManager)} from `{addressManagerFilePath}`.");
}
catch (DirectoryNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{addressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
addressManager = new AddressManager();
}
catch (FileNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{addressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
addressManager = new AddressManager();
}
connectionParameters.TemplateBehaviors.Add(new AddressManagerBehavior(addressManager));
var memPoolService = new MemPoolService();
connectionParameters.TemplateBehaviors.Add(new MemPoolBehavior(memPoolService));
var nodes = new NodesGroup(network, connectionParameters, requirements: Helpers.Constants.NodeRequirements);
BitcoinStore bitcoinStore = new BitcoinStore();
await bitcoinStore.InitializeAsync(Path.Combine(Global.Instance.DataDir, nameof(TestServicesAsync)), network);
KeyManager keyManager = KeyManager.CreateNew(out _, "password");
WasabiSynchronizer syncer = new WasabiSynchronizer(network, bitcoinStore, new Uri("http://localhost:12345"), Global.Instance.TorSocks5Endpoint);
WalletService walletService = new WalletService(
bitcoinStore,
keyManager,
syncer,
new CcjClient(syncer, network, keyManager, new Uri("http://localhost:12345"), Global.Instance.TorSocks5Endpoint),
memPoolService,
nodes,
Global.Instance.DataDir,
new ServiceConfiguration(50, 2, 21, 50, new IPEndPoint(IPAddress.Loopback, network.DefaultPort), Money.Coins(0.0001m)));
Assert.True(Directory.Exists(blocksFolderPath));
try
{
nodes.ConnectedNodes.Added += ConnectedNodes_Added;
nodes.ConnectedNodes.Removed += ConnectedNodes_Removed;
memPoolService.TransactionReceived += MemPoolService_TransactionReceived;
nodes.Connect();
// Using the interlocked, not because it makes sense in this context, but to
// set an example that these values are often concurrency sensitive
var times = 0;
while (Interlocked.Read(ref _nodeCount) < 3)
{
if (times > 4200) // 7 minutes
{
throw new TimeoutException($"Connection test timed out.");
}
await Task.Delay(100);
times++;
}
times = 0;
while (Interlocked.Read(ref _mempoolTransactionCount) < 3)
{
if (times > 3000) // 3 minutes
{
throw new TimeoutException($"{nameof(MemPoolService)} test timed out.");
}
await Task.Delay(100);
times++;
}
foreach (var hash in blocksToDownload)
{
using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(3)))
{
var block = await walletService.GetOrDownloadBlockAsync(hash, cts.Token);
Assert.True(File.Exists(Path.Combine(blocksFolderPath, hash.ToString())));
Logger.LogInfo <P2pTests>($"Full block is downloaded: {hash}.");
}
}
}
finally
{
nodes.ConnectedNodes.Added -= ConnectedNodes_Added;
nodes.ConnectedNodes.Removed -= ConnectedNodes_Removed;
memPoolService.TransactionReceived -= MemPoolService_TransactionReceived;
// So next test will download the block.
foreach (var hash in blocksToDownload)
{
await walletService?.DeleteBlockAsync(hash);
}
if (walletService != null)
{
await walletService.StopAsync();
}
if (Directory.Exists(blocksFolderPath))
{
Directory.Delete(blocksFolderPath, recursive: true);
}
IoHelpers.EnsureContainingDirectoryExists(addressManagerFilePath);
addressManager?.SavePeerFile(addressManagerFilePath, network);
Logger.LogInfo <P2pTests>($"Saved {nameof(AddressManager)} to `{addressManagerFilePath}`.");
nodes?.Dispose();
await syncer?.StopAsync();
}
}
public AddressController(W4rtaDBContext context)
{
this.context = context;
addressManager = new AddressManager(this.context);
}
public void Start()
{
this.parameters.UserAgent = "StratisBitcoin:" + GetVersion();
this.parameters.Version = this.NodeSettings.ProtocolVersion;
if (this.connectionManagerSettings.Connect.Count == 0)
{
NodeConnectionParameters cloneParameters = this.parameters.Clone();
cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this));
this.DiscoveredNodeGroup = CreateNodeGroup(cloneParameters, this.discoveredNodeRequiredService);
this.DiscoveredNodeGroup.CustomGroupSelector = WellKnownGroupSelectors.ByNetwork; //is the default, but I want to use it
this.DiscoveredNodeGroup.Connect();
}
else
{
NodeConnectionParameters cloneParameters = this.parameters.Clone();
cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this));
cloneParameters.TemplateBehaviors.Remove <AddressManagerBehavior>();
var addrman = new AddressManager();
addrman.Add(this.connectionManagerSettings.Connect.Select(c => new NetworkAddress(c)).ToArray(), IPAddress.Loopback);
var addrmanBehavior = new AddressManagerBehavior(addrman);
addrmanBehavior.Mode = AddressManagerBehaviorMode.None;
cloneParameters.TemplateBehaviors.Add(addrmanBehavior);
this.ConnectNodeGroup = CreateNodeGroup(cloneParameters, NodeServices.Nothing);
this.ConnectNodeGroup.MaximumNodeConnection = this.connectionManagerSettings.Connect.Count;
this.ConnectNodeGroup.CustomGroupSelector = WellKnownGroupSelectors.ByEndpoint;
this.ConnectNodeGroup.Connect();
}
{
NodeConnectionParameters cloneParameters = this.parameters.Clone();
cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(false, this));
cloneParameters.TemplateBehaviors.Remove <AddressManagerBehavior>();
var addrman = new AddressManager();
addrman.Add(this.connectionManagerSettings.AddNode.Select(c => new NetworkAddress(c)).ToArray(), IPAddress.Loopback);
var addrmanBehavior = new AddressManagerBehavior(addrman);
addrmanBehavior.Mode = AddressManagerBehaviorMode.AdvertizeDiscover;
cloneParameters.TemplateBehaviors.Add(addrmanBehavior);
this.AddNodeNodeGroup = CreateNodeGroup(cloneParameters, NodeServices.Nothing);
this.AddNodeNodeGroup.MaximumNodeConnection = this.connectionManagerSettings.AddNode.Count;
this.AddNodeNodeGroup.CustomGroupSelector = WellKnownGroupSelectors.ByEndpoint;
this.AddNodeNodeGroup.Connect();
}
StringBuilder 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);
server.LocalEndpoint = listen.Endpoint;
server.ExternalEndpoint = this.connectionManagerSettings.ExternalEndpoint;
this.Servers.Add(server);
cloneParameters.TemplateBehaviors.Add(new ConnectionManagerBehavior(true, this)
{
Whitelisted = listen.Whitelisted
});
server.InboundNodeConnectionParameters = cloneParameters;
server.Listen();
logs.Append(listen.Endpoint.Address + ":" + listen.Endpoint.Port);
if (listen.Whitelisted)
{
logs.Append(" (whitelisted)");
}
logs.AppendLine();
}
Logs.ConnectionManager.LogInformation(logs.ToString());
}
public static void InitializeNoWallet()
{
WalletService = null;
ChaumianClient = null;
AppDomain.CurrentDomain.ProcessExit += async(s, e) => await TryDesperateDequeueAllCoinsAsync();
Console.CancelKeyPress += async(s, e) =>
{
e.Cancel = true;
Logger.LogWarning("Process was signaled for killing.", nameof(Global));
await TryDesperateDequeueAllCoinsAsync();
Dispatcher.UIThread.Post(() =>
{
Application.Current.MainWindow.Close();
});
};
var addressManagerFolderPath = Path.Combine(DataDir, "AddressManager");
AddressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{Network}.dat");
var blocksFolderPath = Path.Combine(DataDir, $"Blocks{Network}");
var connectionParameters = new NodeConnectionParameters();
AddressManager = null;
TorManager = null;
TorManager = new TorProcessManager(Config.GetTorSocks5EndPoint(), TorLogsFile);
TorManager.Start(false, DataDir);
var fallbackRequestTestUri = new Uri(Config.GetFallbackBackendUri(), "/api/software/versions");
TorManager.StartMonitor(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(7), DataDir, fallbackRequestTestUri);
Logger.LogInfo <TorProcessManager>($"{nameof(TorProcessManager)} is initialized.");
var needsToDiscoverPeers = true;
if (Network == Network.RegTest)
{
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"Fake {nameof(AddressManager)} is initialized on the RegTest.");
}
else
{
try
{
AddressManager = AddressManager.LoadPeerFile(AddressManagerFilePath);
needsToDiscoverPeers = AddressManager.Count < 200;
Logger.LogInfo <AddressManager>($"Loaded {nameof(AddressManager)} from `{AddressManagerFilePath}`.");
}
catch (DirectoryNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (FileNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (OverflowException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/712
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} has thrown `{nameof(OverflowException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} autocorrection is successful.");
}
catch (FormatException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/880
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} has thrown `{nameof(FormatException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} autocorrection is successful.");
}
}
var addressManagerBehavior = new AddressManagerBehavior(AddressManager);
addressManagerBehavior.Mode = needsToDiscoverPeers ? AddressManagerBehaviorMode.Discover : AddressManagerBehaviorMode.None;
connectionParameters.TemplateBehaviors.Add(addressManagerBehavior);
MemPoolService = new MemPoolService();
connectionParameters.TemplateBehaviors.Add(new MemPoolBehavior(MemPoolService));
if (Network == Network.RegTest | Network.Name == "chaincoin-reg") //todopw: extend
{
Nodes = new NodesGroup(Network, requirements: Constants.NodeRequirements);
try
{
// todopw: extend
Node node;
if (Network.Name == "chaincoin-reg")
{
node = Node.Connect(NBitcoin.Altcoins.Chaincoin.Instance.Regtest, new IPEndPoint(IPAddress.Loopback, 18444));
}
else
{
node = Node.Connect(Network.RegTest, new IPEndPoint(IPAddress.Loopback, 18444));
}
Nodes.ConnectedNodes.Add(node);
RegTestMemPoolServingNode = Node.Connect(Network.RegTest, new IPEndPoint(IPAddress.Loopback, 18444));
RegTestMemPoolServingNode.Behaviors.Add(new MemPoolBehavior(MemPoolService));
}
catch (SocketException ex)
{
Logger.LogError(ex, nameof(Global));
}
}
else
{
Nodes = new NodesGroup(Network, connectionParameters, requirements: Constants.NodeRequirements);
RegTestMemPoolServingNode = null;
}
// todopw: Error UpdateChecker just chc - No connection could be made because the target machine actively refused it 127.0.0.1:37127
Synchronizer = new WasabiSynchronizer(Network, IndexFilePath, Config.GetCurrentBackendUri(), Config.GetTorSocks5EndPoint());
UpdateChecker = new UpdateChecker(Synchronizer.WasabiClient);
Nodes.Connect();
Logger.LogInfo("Start connecting to nodes...");
if (!(RegTestMemPoolServingNode is null))
{
RegTestMemPoolServingNode.VersionHandshake();
Logger.LogInfo("Start connecting to mempool serving regtest node...");
}
var requestInterval = TimeSpan.FromSeconds(30);
if (Network == Network.RegTest || Network.Name == "chaincoin-reg") // todopw: extend
{
requestInterval = TimeSpan.FromSeconds(5);
}
Synchronizer.Start(requestInterval, TimeSpan.FromMinutes(5), 1000);
Logger.LogInfo("Start synchronizing filters...");
}
public void Get_RoutedAddress()
{
InitAddressRecords();
DomainManager dMgr = new DomainManager(CreateConfigStore());
Domain domain = new Domain("address1.domain1.com");
domain.Status = EntityStatus.Enabled;
dMgr.Add(domain);
string addressType = "Undeliverable";
AddressManager aMgr = new AddressManager(CreateConfigStore());
MailAddress address = new MailAddress("*****@*****.**");
aMgr.Add(address, EntityStatus.Enabled, addressType);
//
// [email protected] aready exists
//
AddressManager mgr = CreateManager();
string[] emailAddresses = new[] { "*****@*****.**" };
IEnumerable<Address> actual = mgr.Get(emailAddresses, true, EntityStatus.Enabled);
Assert.Equal(1, actual.Count());
for (int t = 0; t < actual.Count(); t++)
{
Assert.True(emailAddresses.Any(e => e.Equals(actual.ToArray()[t].EmailAddress, StringComparison.OrdinalIgnoreCase)));
Assert.Equal(EntityStatus.Enabled, actual.ToArray()[t].Status);
Assert.Equal(addressType, actual.ToArray()[t].Type);
}
actual = mgr.Get(emailAddresses, EntityStatus.Enabled);
Assert.Equal(1, actual.Count());
for (int t = 0; t < actual.Count(); t++)
{
Assert.True(emailAddresses.Any(e => e.Equals(actual.ToArray()[t].EmailAddress, StringComparison.OrdinalIgnoreCase)));
Assert.Equal(EntityStatus.Enabled, actual.ToArray()[t].Status);
Assert.Equal(addressType, actual.ToArray()[t].Type);
}
actual = mgr.Get(emailAddresses, true);
Assert.Equal(1, actual.Count());
for (int t = 0; t < actual.Count(); t++)
{
Assert.True(emailAddresses.Any(e => e.Equals(actual.ToArray()[t].EmailAddress, StringComparison.OrdinalIgnoreCase)));
Assert.Equal(EntityStatus.Enabled, actual.ToArray()[t].Status);
Assert.Equal(addressType, actual.ToArray()[t].Type);
}
actual = mgr.Get(emailAddresses);
Assert.Equal(1, actual.Count());
for (int t = 0; t < actual.Count(); t++)
{
Assert.True(emailAddresses.Any(e => e.Equals(actual.ToArray()[t].EmailAddress, StringComparison.OrdinalIgnoreCase)));
Assert.Equal(EntityStatus.Enabled, actual.ToArray()[t].Status);
Assert.Equal(addressType, actual.ToArray()[t].Type);
}
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
try
{
bool nameAvailable = true;
Site currentSite = null;
if (!string.IsNullOrEmpty(lblSiteId.Text))
{
currentSite = SiteManager.GetSiteById(lblSiteId.Text);
}
Site site = SiteManager.GetSiteByName(txtSiteName.Text);
if (site != null)
{
if (currentSite != null)
{
if (site != null && site.Id != currentSite.Id)
{
nameAvailable = false;
((IFeedback)Page.Master).ShowFeedback(Feedback.Actions.Error, "Site " + txtSiteName.Text + " already exists");
}
}
else //new site
{
nameAvailable = false;
((IFeedback)Page.Master).ShowFeedback(Feedback.Actions.Error, "Region " + txtSiteName.Text + " already exists");
}
}
if (nameAvailable)
{
// Figure out the address.
Address physicalAddress = CreatePhysicalAddressFromFields();
//if (physicalAddress == null)
// physicalAddress = new Address();
Address postalAddress = CreatePostalAddressFromFields();
//if (postalAddress == null)
// postalAddress = new Address();
if (currentSite == null)
{
// Create a new site.
currentSite = new Site();
currentSite.Name = txtSiteName.Text;
// Just get the first available site type. We don't use site types at the moment.
currentSite.SiteType = SiteManager.GetAllSiteTypes()[0];
currentSite.PhoneNumber = txtPhoneNumber.Text;
currentSite.AltPhoneNumber = txtAltPhoneNumber.Text;
currentSite.Email = txtEmail.Text;
currentSite.Region = (Region)regions[cmbRegions.SelectedIndex];
currentSite.PhysicalAddress = physicalAddress;
currentSite.PostalAddress = postalAddress;
SiteManager.CreateSite(currentSite);
lblSiteId.Text = SiteManager.GetSiteByName(currentSite.Name).Id;
RefreshData(SiteManager.GetSiteByName(currentSite.Name).Id);
btnUpdate.Text = UpdateSite;
((IFeedback)Master).QueueFeedback(BusiBlocksConstants.Blocks.Administration.LongName,
currentSite.GetType().Name, Feedback.Actions.Created, currentSite.Name);
Navigation.Admin_ManageLocations().Redirect(this);
}
else
{
if (physicalAddress != null)
{
if (currentSite.PhysicalAddress == null)
{
currentSite.PhysicalAddress = new Address();
}
currentSite.PhysicalAddress.Address1 = physicalAddress.Address1;
currentSite.PhysicalAddress.Address2 = physicalAddress.Address2;
currentSite.PhysicalAddress.Suburb = physicalAddress.Suburb;
currentSite.PhysicalAddress.Postcode = physicalAddress.Postcode;
currentSite.PhysicalAddress.State = physicalAddress.State;
if (string.IsNullOrEmpty(currentSite.PhysicalAddress.Id))
{
AddressManager.CreateAddress(currentSite.PhysicalAddress);
}
else
{
AddressManager.UpdateAddress(currentSite.PhysicalAddress);
}
}
else if (physicalAddress == null && currentSite.PhysicalAddress != null)
{
// Delete the address.
AddressManager.DeleteAddress(currentSite.PhysicalAddress);
currentSite.PhysicalAddress = null;
}
if (postalAddress != null)
{
if (currentSite.PostalAddress == null)
{
currentSite.PostalAddress = new Address();
}
currentSite.PostalAddress.Address1 = postalAddress.Address1;
currentSite.PostalAddress.Address2 = postalAddress.Address2;
currentSite.PostalAddress.Suburb = postalAddress.Suburb;
currentSite.PostalAddress.Postcode = postalAddress.Postcode;
currentSite.PostalAddress.State = postalAddress.State;
if (string.IsNullOrEmpty(currentSite.PostalAddress.Id))
{
AddressManager.CreateAddress(currentSite.PostalAddress);
}
else
{
AddressManager.UpdateAddress(currentSite.PostalAddress);
}
}
else if (postalAddress == null && currentSite.PostalAddress != null)
{
// Delete the address.
AddressManager.DeleteAddress(currentSite.PostalAddress);
currentSite.PostalAddress = null;
}
currentSite.Name = txtSiteName.Text;
currentSite.PhoneNumber = txtPhoneNumber.Text;
currentSite.AltPhoneNumber = txtAltPhoneNumber.Text;
currentSite.Email = txtEmail.Text;
currentSite.Region = (Region)regions[cmbRegions.SelectedIndex];
SiteManager.UpdateSite(currentSite);
((IFeedback)Master).QueueFeedback(BusiBlocksConstants.Blocks.Administration.LongName,
currentSite.GetType().Name, Feedback.Actions.Saved, currentSite.Name);
Navigation.Admin_ManageLocations().Redirect(this);
}
}
}
catch (Exception ex)
{
throw ex;
((IFeedback)Master).SetException(GetType(), ex);
}
}
public static void InitializeNoWallet()
{
WalletService = null;
ChaumianClient = null;
AppDomain.CurrentDomain.ProcessExit += async(s, e) => await TryDesperateDequeueAllCoinsAsync();
Console.CancelKeyPress += async(s, e) =>
{
e.Cancel = true;
Logger.LogWarning("Process was signaled for killing.", nameof(Global));
await TryDesperateDequeueAllCoinsAsync();
Dispatcher.UIThread.Post(() =>
{
Application.Current.MainWindow.Close();
});
};
var addressManagerFolderPath = Path.Combine(DataDir, "AddressManager");
AddressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{Network}.dat");
var blocksFolderPath = Path.Combine(DataDir, $"Blocks{Network}");
var connectionParameters = new NodeConnectionParameters();
AddressManager = null;
TorManager = null;
TorManager = new TorProcessManager(Config.GetTorSocks5EndPoint(), TorLogsFile);
TorManager.Start(false, DataDir);
Logger.LogInfo <TorProcessManager>($"{nameof(TorProcessManager)} is initialized.");
if (Network == Network.RegTest)
{
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"Fake {nameof(AddressManager)} is initialized on the RegTest.");
}
else
{
try
{
AddressManager = AddressManager.LoadPeerFile(AddressManagerFilePath);
Logger.LogInfo <AddressManager>($"Loaded {nameof(AddressManager)} from `{AddressManagerFilePath}`.");
}
catch (DirectoryNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (FileNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
}
connectionParameters.TemplateBehaviors.Add(new AddressManagerBehavior(AddressManager));
MemPoolService = new MemPoolService();
connectionParameters.TemplateBehaviors.Add(new MemPoolBehavior(MemPoolService));
if (Network == Network.RegTest)
{
Nodes = new NodesGroup(Network,
requirements: new NodeRequirement
{
RequiredServices = NodeServices.Network,
MinVersion = Constants.ProtocolVersion_WITNESS_VERSION
});
Nodes.ConnectedNodes.Add(Node.Connect(Network.RegTest, new IPEndPoint(IPAddress.Loopback, 18444)));
RegTestMemPoolServingNode = Node.Connect(Network.RegTest, new IPEndPoint(IPAddress.Loopback, 18444));
RegTestMemPoolServingNode.Behaviors.Add(new MemPoolBehavior(MemPoolService));
}
else
{
Nodes = new NodesGroup(Network, connectionParameters,
new NodeRequirement
{
RequiredServices = NodeServices.Network,
MinVersion = Constants.ProtocolVersion_WITNESS_VERSION
});
RegTestMemPoolServingNode = null;
}
IndexDownloader = new IndexDownloader(Network, IndexFilePath, Config.GetCurrentBackendUri(), Config.GetTorSocks5EndPoint());
UpdateChecker = new UpdateChecker(IndexDownloader.WasabiClient);
Nodes.Connect();
Logger.LogInfo("Start connecting to nodes...");
if (!(RegTestMemPoolServingNode is null))
{
RegTestMemPoolServingNode.VersionHandshake();
Logger.LogInfo("Start connecting to mempool serving regtest node...");
}
IndexDownloader.Synchronize(requestInterval: TimeSpan.FromSeconds(21));
Logger.LogInfo("Start synchronizing filters...");
}
private static async Task <AddressManagerBehavior> InitializeAddressManagerBehaviorAsync()
{
var needsToDiscoverPeers = true;
if (Network == Network.RegTest)
{
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"Fake {nameof(AddressManager)} is initialized on the RegTest.");
}
else
{
try
{
AddressManager = await NBitcoinHelpers.LoadAddressManagerFromPeerFileAsync(AddressManagerFilePath);
// The most of the times we don't need to discover new peers. Instead, we can connect to
// some of those that we already discovered in the past. In this case we assume that we
// assume that discovering new peers could be necessary if out address manager has less
// than 500 addresses. A 500 addresses could be okay because previously we tried with
// 200 and only one user reported he/she was not able to connect (there could be many others,
// of course).
// On the other side, increasing this number forces users that do not need to discover more peers
// to spend resources (CPU/bandwith) to discover new peers.
needsToDiscoverPeers = Config.UseTor == true || AddressManager.Count < 500;
Logger.LogInfo <AddressManager>($"Loaded {nameof(AddressManager)} from `{AddressManagerFilePath}`.");
}
catch (DirectoryNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (FileNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (OverflowException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/712
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} has thrown `{nameof(OverflowException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} autocorrection is successful.");
}
catch (FormatException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/880
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} has thrown `{nameof(FormatException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} autocorrection is successful.");
}
}
var addressManagerBehavior = new AddressManagerBehavior(AddressManager)
{
Mode = needsToDiscoverPeers ? AddressManagerBehaviorMode.Discover : AddressManagerBehaviorMode.None
};
return(addressManagerBehavior);
}
public static void Extract()
{
using (var spinner = new ConsoleSpinner())
{
spinner.Start();
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
System.Diagnostics.Stopwatch stopwatch2 = new System.Diagnostics.Stopwatch();
stopwatch.Start();
writeConsole("#####################################");
writeConsole("###### ######");
writeConsole("###### Start Extract Address ######");
writeConsole("###### ######");
writeConsole("#####################################");
writeConsole("-------------------------------------");
writeConsole();
using (DataTable dtProvince = db.getDataProvince())
{
using (DataTable dtYears = db.getYearCreateAddress())
{
DataTable dt;
DataTable dtAddress;
string _year;
AddressManager _ex = new AddressManager(dtProvince);
foreach (DataRow _dr in dtYears.Rows)
{
stopwatch2.Start();
try
{
_year = Convert.ToString(_dr["years"]);
dtAddress = db.getDataAddress(_year);
writeConsole(string.Format("=> GetAddress from year : {0}", _dr["years"]), consoleType.info);
writeConsole(string.Format("=> Total Rows : {0}", dtAddress.Rows.Count.ToString("n0")), consoleType.info);
writeConsole(string.Format("=>> GetAddress Success : {0}", stopwatch2.Elapsed), consoleType.warn);
writeConsole();
if (dtAddress != null && dtAddress.Rows.Count > 0)
{
writeConsole(string.Format("=>> Start Extract Address : {0}", stopwatch2.Elapsed));
dt = _ex.eXtract(dtAddress, _year);
writeConsole(string.Format("=>> Extract Address Success : {0}", stopwatch2.Elapsed), consoleType.warn);
writeConsole();
writeConsole(string.Format("=>> Start Clear Exists Data : {0}", stopwatch2.Elapsed));
db.clearExistsDataIn_TbExtract(dt);
writeConsole(string.Format("=>> Clear Exists Data Success : {0}", stopwatch2.Elapsed), consoleType.warn);
writeConsole();
writeConsole(string.Format("=>> Start Insert into DB : {0}", stopwatch2.Elapsed));
db.insertBulkToImportDB("tempAddress", dt);
writeConsole(string.Format("=>> Insert into DB Success : {0}", stopwatch2.Elapsed), consoleType.warn);
writeConsole();
dt.Dispose();
}
dtAddress.Dispose();
writeConsole("=>>> Success \\(^.^)/", consoleType.success);
}
catch (Exception ex)
{
writeConsole("=>>> Error /(-_-\")\\ ", consoleType.error);
writeConsole(string.Format("=>>> : {0}", ex.Message), consoleType.error);
}
writeConsole("-------------------------------------");
writeConsole();
stopwatch2.Stop();
stopwatch2.Reset();
//break;
}
}
}
stopwatch.Stop();
writeConsole("-------------------------------------");
writeConsole(string.Format("### Time elapsed: {0} ###", stopwatch.Elapsed));
}
Console.ReadLine();
}
public P2pNetwork(Network network, EndPoint fullnodeP2pEndPoint, EndPoint?torSocks5EndPoint, string workDir, BitcoinStore bitcoinStore)
{
Network = network;
FullnodeP2PEndPoint = fullnodeP2pEndPoint;
TorSocks5EndPoint = torSocks5EndPoint;
WorkDir = workDir;
BitcoinStore = bitcoinStore;
var userAgent = Constants.UserAgents.RandomElement();
var connectionParameters = new NodeConnectionParameters {
UserAgent = userAgent
};
connectionParameters.TemplateBehaviors.Add(BitcoinStore.CreateUntrustedP2pBehavior());
AddressManagerFilePath = Path.Combine(WorkDir, $"AddressManager{Network}.dat");
var needsToDiscoverPeers = true;
if (Network == Network.RegTest)
{
AddressManager = new AddressManager();
Logger.LogInfo($"Fake {nameof(AddressManager)} is initialized on the {Network.RegTest}.");
}
else
{
try
{
AddressManager = AddressManager.LoadPeerFile(AddressManagerFilePath);
// Most of the times we do not need to discover new peers. Instead, we can connect to
// some of those that we already discovered in the past. In this case we assume that
// discovering new peers could be necessary if our address manager has less
// than 500 addresses. 500 addresses could be okay because previously we tried with
// 200 and only one user reported he/she was not able to connect (there could be many others,
// of course).
// On the other side, increasing this number forces users that do not need to discover more peers
// to spend resources (CPU/bandwidth) to discover new peers.
needsToDiscoverPeers = TorSocks5EndPoint is not null || AddressManager.Count < 500;
Logger.LogInfo($"Loaded {nameof(AddressManager)} from `{AddressManagerFilePath}`.");
}
catch (DirectoryNotFoundException ex)
{
Logger.LogInfo($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace(ex);
AddressManager = new AddressManager();
}
catch (FileNotFoundException ex)
{
Logger.LogInfo($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace(ex);
AddressManager = new AddressManager();
}
catch (OverflowException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/712
Logger.LogInfo($"{nameof(AddressManager)} has thrown `{nameof(OverflowException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace(ex);
AddressManager = new AddressManager();
Logger.LogInfo($"{nameof(AddressManager)} autocorrection is successful.");
}
catch (FormatException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/880
Logger.LogInfo($"{nameof(AddressManager)} has thrown `{nameof(FormatException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace(ex);
AddressManager = new AddressManager();
Logger.LogInfo($"{nameof(AddressManager)} autocorrection is successful.");
}
}
var addressManagerBehavior = new AddressManagerBehavior(AddressManager)
{
Mode = needsToDiscoverPeers ? AddressManagerBehaviorMode.Discover : AddressManagerBehaviorMode.None
};
connectionParameters.TemplateBehaviors.Add(addressManagerBehavior);
if (Network == Network.RegTest)
{
Nodes = new NodesGroup(Network, requirements: Constants.NodeRequirements);
}
else
{
var maximumNodeConnection = 12;
var bestEffortEndpointConnector = new BestEffortEndpointConnector(maximumNodeConnection / 2);
connectionParameters.EndpointConnector = bestEffortEndpointConnector;
if (TorSocks5EndPoint is not null)
{
connectionParameters.TemplateBehaviors.Add(new SocksSettingsBehavior(TorSocks5EndPoint, onlyForOnionHosts: false, networkCredential: null, streamIsolation: true));
}
var nodes = new NodesGroup(Network, connectionParameters, requirements: Constants.NodeRequirements);
nodes.ConnectedNodes.Added += ConnectedNodes_OnAddedOrRemoved;
nodes.ConnectedNodes.Removed += ConnectedNodes_OnAddedOrRemoved;
nodes.MaximumNodeConnection = maximumNodeConnection;
Nodes = nodes;
}
}
private void CreateCompanyAddress()
{
AddressManager.CreateCompanyAddress(SelectedCategoryId, Name, Account);
this.Close();
}
public AddressController(AddressManager am)
{
_addressManager = am;
}
public TriggerManager(AddressManager address, Offsets offsets)
{
_offsets = offsets;
_address = address;
}
public static void InitializeNoWallet()
{
WalletService = null;
ChaumianClient = null;
AppDomain.CurrentDomain.ProcessExit += async(s, e) => await TryDesperateDequeueAllCoinsAsync();
Console.CancelKeyPress += async(s, e) =>
{
e.Cancel = true;
Logger.LogWarning("Process was signaled for killing.", nameof(Global));
await TryDesperateDequeueAllCoinsAsync();
Dispatcher.UIThread.Post(() =>
{
Application.Current.MainWindow.Close();
});
};
var addressManagerFolderPath = Path.Combine(DataDir, "AddressManager");
AddressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{Network}.dat");
var blocksFolderPath = Path.Combine(DataDir, $"Blocks{Network}");
var connectionParameters = new NodeConnectionParameters();
AddressManager = null;
TorManager = null;
TorManager = new TorProcessManager(Config.GetTorSocks5EndPoint(), TorLogsFile);
TorManager.Start(false, DataDir);
var fallbackRequestTestUri = new Uri(Config.GetFallbackBackendUri(), "/api/software/versions");
TorManager.StartMonitor(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(7), DataDir, fallbackRequestTestUri);
Logger.LogInfo <TorProcessManager>($"{nameof(TorProcessManager)} is initialized.");
var needsToDiscoverPeers = true;
if (Network == Network.RegTest)
{
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"Fake {nameof(AddressManager)} is initialized on the RegTest.");
}
else
{
try
{
AddressManager = AddressManager.LoadPeerFile(AddressManagerFilePath);
// The most of the times we don't need to discover new peers. Instead, we can connect to
// some of those that we already discovered in the past. In this case we assume that we
// assume that discovering new peers could be necessary if out address manager has less
// than 500 addresses. A 500 addresses could be okay because previously we tried with
// 200 and only one user reported he/she was not able to connect (there could be many others,
// of course).
// On the other side, increasing this number forces users that do not need to discover more peers
// to spend resources (CPU/bandwith) to discover new peers.
needsToDiscoverPeers = AddressManager.Count < 500;
Logger.LogInfo <AddressManager>($"Loaded {nameof(AddressManager)} from `{AddressManagerFilePath}`.");
}
catch (DirectoryNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (FileNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (OverflowException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/712
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} has thrown `{nameof(OverflowException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} autocorrection is successful.");
}
catch (FormatException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/880
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} has thrown `{nameof(FormatException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} autocorrection is successful.");
}
}
var addressManagerBehavior = new AddressManagerBehavior(AddressManager)
{
Mode = needsToDiscoverPeers ? AddressManagerBehaviorMode.Discover : AddressManagerBehaviorMode.None
};
connectionParameters.TemplateBehaviors.Add(addressManagerBehavior);
MemPoolService = new MemPoolService();
connectionParameters.TemplateBehaviors.Add(new MemPoolBehavior(MemPoolService));
if (Network == Network.RegTest)
{
Nodes = new NodesGroup(Network, requirements: Constants.NodeRequirements);
try
{
Node node = Node.Connect(Network.RegTest, new IPEndPoint(IPAddress.Loopback, 18444));
Nodes.ConnectedNodes.Add(node);
RegTestMemPoolServingNode = Node.Connect(Network.RegTest, new IPEndPoint(IPAddress.Loopback, 18444));
RegTestMemPoolServingNode.Behaviors.Add(new MemPoolBehavior(MemPoolService));
}
catch (SocketException ex)
{
Logger.LogError(ex, nameof(Global));
}
}
else
{
Nodes = new NodesGroup(Network, connectionParameters, requirements: Constants.NodeRequirements);
RegTestMemPoolServingNode = null;
}
Synchronizer = new WasabiSynchronizer(Network, IndexFilePath, Config.GetCurrentBackendUri(), Config.GetTorSocks5EndPoint());
UpdateChecker = new UpdateChecker(Synchronizer.WasabiClient);
Nodes.Connect();
Logger.LogInfo("Start connecting to nodes...");
if (!(RegTestMemPoolServingNode is null))
{
RegTestMemPoolServingNode.VersionHandshake();
Logger.LogInfo("Start connecting to mempool serving regtest node...");
}
var requestInterval = TimeSpan.FromSeconds(30);
if (Network == Network.RegTest)
{
requestInterval = TimeSpan.FromSeconds(5);
}
Synchronizer.Start(requestInterval, TimeSpan.FromMinutes(5), 1000);
Logger.LogInfo("Start synchronizing filters...");
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!\n");
using (var context = DbContextFactory.Create()) //no 'NEW' b/c of static class
{
Console.WriteLine("Test");
}
//ADDRESS HANDLING ------------------------------------
AddressManager addrmgr = new AddressManager();
var newAddress = new Address
{
Street = "3001 Hilltop Dr",
City = "Novi",
State = "Mi",
Zip = 48335,
Addresstype = Address.AddressTypes.SHIPPING
};
//CREATE ADDRESS:
//addrmgr.CreateAddress(newAddress);
/*
* Address updateAddress = new Address
* {
* CustomerDetails = {Id = 1},
* Id = 2,
* Street = "8 Eight Lane",
* City = "Maui",
* State = "Hi",
* Zip = 98765,
* Addresstype = Address.AddressTypes.SHIPPING
* };*/
//UPDATE ADDRESS:
//addrmgr.UpdateAddress(updateAddress);
//REMOVE ADDRESS:
//addrmgr.RemoveAddress(8);
//RETRIEVE ADDRESS (ex; by customer Id
//var addrrr = addrmgr.GetAddress(4);
//Console.WriteLine(addrrr.First().Id);
//PRODUCT HANDLING ------------------------------------------
Product updateProd = new Product
{
Id = 3,
Name = "Widget 5000 Updated",
Price = 42.99
};
Product newProd2 = new Product
{
Name = "Widget B",
Price = 5.00
};
ProductManager prodmgr = new ProductManager();
//----RETRIEVE PRODUCT
//var prod = prodmgr.GetProduct(1);
//Console.WriteLine(prod.Name);
//----UPDATE PRODUCT
//prodmgr.UpdateProduct(updateProd);
//----CREATE PRODUCT
//prodmgr.CreateProduct(newProd2);
//xxxx REMOVE PRODUCT - constraints <----- RETURN TO THIS
//prodmgr.RemoveProduct(7);
//SHIPPING METHOD HANDLING ------------------------------------------
ShippingMethod updateMethod = new ShippingMethod
{
Id = 2,
Method = "2nd Day",
Carrier = "Fedex"
};
ShippingMethod newMethod1 = new ShippingMethod
{
Carrier = "UPS",
Method = "Overnight"
};
ShipMethodManager shipmgr = new ShipMethodManager();
//----RETRIEVE SHIPMETHOD
//var m = shipmgr.GetShipMethod(1);
//Console.WriteLine(m.Method);
//----UPDATE SHIPMETHOD
//shipmgr.UpdateShipMethod(updateMethod);
//-----CREATE SHIPMETHOD
//shipmgr.CreateShipMethod(newMethod1);
//xxxx REMOVE SHIPMETHOD -> dependencies <----- RETURN TO THIS
//shipmgr.RemoveShipMethod(3);
//CUSTOMER HANDLING ------------------------------------------
CustomerManager custmgr = new CustomerManager();
//----RETRIEVE CUSTOMER - ok
//var cust = custmgr.GetCustomer(2);
//Console.WriteLine(cust.Name);
Customer updatedCustomer = new Customer
{
Id = 2,
Name = "My New Customer LLC"
};
Customer newCustomer = new Customer
{
Name = "Smart Data Systems",
Addresses = new List <Address>
{
new Address
{
Street = "8571 Gander Creek Dr",
City = "Miamisburg",
State = "OH",
Zip = 45342,
Addresstype = Address.AddressTypes.SHIPPING
},
new Address
{
Street = "8570 Gander Creek Dr",
City = "Miamisburg",
State = "OH",
Zip = 45342,
Addresstype = Address.AddressTypes.BILLING
},
}
};
//UPDATE CUSTOMER - ok
//custmgr.UpdateCustomer(updatedCustomer);
//CREATE CUSTOMER - ok
//custmgr.CreateCustomer(newCustomer);
//REMOVE CUSTOMER -> dependencies... this is odd... but it works...
//custmgr.RemoveCustomer(7);
//LINE ITEM HANDLING ------------------------------------------
// LineItem updatedLine = new LineItem
//{ Id = 9, ProductDetails = new Product { Id = 2 }, Quantity = 100, Discount = 0.05, OrderDetailsId = 3};
// LineItem newLine = new LineItem
//{ ProductDetails = new Product { Id = 2 }, Quantity = 2, Discount = 0.05, OrderDetailsId = 2 };
LineItemManager linemgr = new LineItemManager();
//RETRIEVE LINE - ok
//linemgr.GetLineItem(4);
//UPDATE LINE - ok
//linemgr.UpdateLineItem(updatedLine);
//CREATE LINE
//linemgr.CreateLineItem(newLine);
//REMOVE LINE
//linemgr.RemoveLineItem(2);
//ORDER HANDLING ----------------------------------------------------------
OrderManager ordermgr = new OrderManager();
var newOrder = new OrderDetails
{
OrderDate = DateTime.Now.ToString("yyyy-MM-dd"),
CustomerDetailsId = 2,
Shipmethod =
{
Id = 1,
Carrier = "UPS",
Method = "Overnight"
},
Lineitems = new LineItem[]
{
new LineItem {
ProductDetailsId = 6, Quantity = 22,
Discount = 0
},
new LineItem {
ProductDetailsId = 5, Quantity = 1,
Discount = 0
}
},
OrderStatus = OrderDetails.ShippingStatus.PROCESSING
};
//CREATE ORDER
//This should take CUSTOMER ID, SHIPPING DETAILS, ARRAY OF LINE ITEMS & CREATE ORDER
//ordermgr.CreateOrder(newOrder);
OrderDetails updatedOrder = new OrderDetails
{
Id = 3,
Lineitems = null,
Shipmethod = { Id = 1 },
OrderStatus = OrderDetails.ShippingStatus.COMPLETED
};
//UPDATE ORDER
//ordermgr.UpdateOrder(updatedOrder);
//RETRIEVE ORDER - per ID (one at a time)
//var ord = ordermgr.GetOrder(1);
//Retrieval variables
int id = 1;
OrderDetails.ShippingStatus orderstatus = OrderDetails.ShippingStatus.PROCESSING;
//RETRIEVE ORDERS FOR CUSTOMER (+ filter param?)
//IQueryable<CustomerOrders> returnorders =
ordermgr.GetCustomerOrders(id, orderstatus);
//Retrieve Status
//CREATE ORDER
//This should take CUSTOMER ID, SHIPPING DETAILS, ARRAY OF LINE ITEMS & CREATE ORDER
//ordermgr.CreateOrder(newOrder);
//CANCEL ORDER / flag it
//ordermgr.CancelOrder(1);
} //end Main
public static void SetAddrman(NodeConnectionParameters parameters, AddressManager addrman)
{
if(parameters == null)
throw new ArgumentNullException("parameters");
SetAddrman(parameters.TemplateBehaviors, addrman);
}
public ClientCompanyProfileService(IClientCompanyManagement clientCompanyManagement, IClientCompanyIdentityGenerator clientCompanyIdentityGenerator, AddressManager addressManager)
{
_clientCompanyManagement = ValidationUtil.CheckOnNullAndThrowIfNull(clientCompanyManagement);
_clientCompanyIdentityGenerator = ValidationUtil.CheckOnNullAndThrowIfNull(clientCompanyIdentityGenerator);
_addressManager = ValidationUtil.CheckOnNullAndThrowIfNull(addressManager);
}
public ImportAddressToWatchController(AddressManager addressManger, MessageBoxService msgBox)
{
this.ImportCommand = new DelegateCommand(ImportAddress);
this.MsgBox = msgBox;
this.AddressManager = addressManger;
}
public async Task StartAsync()
{
if (_Disposed)
{
throw new ObjectDisposedException(nameof(NBxplorerInitializer));
}
_Starting.Reset();
try
{
if (_Network.IsRegTest)
{
if (await _RPC.GetBlockCountAsync() < 100)
{
Logs.Configuration.LogInformation($"Less than 100 blocks, mining some block for regtest");
await _RPC.GenerateAsync(101);
}
else
{
var header = await _RPC.GetBlockHeaderAsync(await _RPC.GetBestBlockHashAsync());
if ((DateTimeOffset.UtcNow - header.BlockTime) > TimeSpan.FromSeconds(24 * 60 * 60))
{
Logs.Configuration.LogInformation($"It has been a while nothing got mined on regtest... mining 10 blocks");
await _RPC.GenerateAsync(10);
}
}
}
var cachePath = Path.Combine(_Configuration.DataDir, "chain.dat");
if (_Configuration.CacheChain && File.Exists(cachePath))
{
Logs.Configuration.LogInformation($"Loading chain from cache...");
_Chain.Load(File.ReadAllBytes(cachePath));
Logs.Configuration.LogInformation($"Height: " + _Chain.Height);
}
var heightBefore = _Chain.Height;
Logs.Configuration.LogInformation($"Loading chain from node...");
using (var node = Node.Connect(_Network.Network, _Configuration.NodeEndpoint))
{
var cts = new CancellationTokenSource();
cts.CancelAfter(5000);
node.VersionHandshake(cts.Token);
node.SynchronizeChain(_Chain);
}
Logs.Configuration.LogInformation("Height: " + _Chain.Height);
if (_Configuration.CacheChain && heightBefore != _Chain.Height)
{
Logs.Configuration.LogInformation($"Saving chain to cache...");
var ms = new MemoryStream();
_Chain.WriteTo(ms);
File.WriteAllBytes(cachePath, ms.ToArray());
Logs.Configuration.LogInformation($"Saved");
}
AddressManager manager = new AddressManager();
manager.Add(new NetworkAddress(_Configuration.NodeEndpoint), IPAddress.Loopback);
NodesGroup group = new NodesGroup(_Network.Network, new NodeConnectionParameters()
{
Services = NodeServices.Nothing,
IsRelay = true,
TemplateBehaviors =
{
new AddressManagerBehavior(manager)
{
PeersToDiscover = 1,
Mode = AddressManagerBehaviorMode.None
},
new ExplorerBehavior(_Repository, _Chain, _Invoker, _Events)
{
StartHeight = _Configuration.StartHeight
},
new ChainBehavior(_Chain)
{
CanRespondToGetHeaders = false
}
}
});
group.AllowSameGroup = true;
group.MaximumNodeConnection = 1;
group.Connect();
_Group = group;
}
finally { _Starting.Set(); }
}
public void CanHandshakeWithSeveralTemplateBehaviors()
{
using (var builder = NodeBuilderEx.Create())
{
var node = builder.CreateNode(true);
node.Generate(101);
AddressManager manager = new AddressManager();
manager.Add(new NetworkAddress(node.NodeEndpoint), IPAddress.Loopback);
var chain = new SlimChain(builder.Network.GenesisHash);
NodesGroup group = new NodesGroup(builder.Network, new NodeConnectionParameters()
{
Services = NodeServices.Nothing,
IsRelay = true,
TemplateBehaviors =
{
new AddressManagerBehavior(manager)
{
PeersToDiscover = 1,
Mode = AddressManagerBehaviorMode.None
},
new SlimChainBehavior(chain),
new PingPongBehavior()
}
});
group.AllowSameGroup = true;
group.MaximumNodeConnection = 1;
var connecting = WaitConnected(group);
try
{
group.Connect();
connecting.GetAwaiter().GetResult();
Eventually(() =>
{
Assert.Equal(101, chain.Height);
});
var ms = new MemoryStream();
chain.Save(ms);
var chain2 = new SlimChain(chain.Genesis);
ms.Position = 0;
chain2.Load(ms);
Assert.Equal(chain.Tip, chain2.Tip);
using (var fs = new FileStream("test.slim.dat", FileMode.Create, FileAccess.Write, FileShare.None, 1024 * 1024))
{
chain.Save(fs);
fs.Flush();
}
chain.ResetToGenesis();
using (var fs = new FileStream("test.slim.dat", FileMode.Open, FileAccess.Read, FileShare.None, 1024 * 1024))
{
chain.Load(fs);
}
Assert.Equal(101, chain2.Height);
chain.ResetToGenesis();
}
finally
{
group.Disconnect();
}
}
}
/// <summary>
/// Connect the wallet with the given connection parameters
/// </summary>
/// <param name="group">The group to use</param>
public void Connect(NodesGroup group)
{
if (group == null)
{
throw new ArgumentNullException("group");
}
if (State != WalletState.Created)
{
throw new InvalidOperationException("The wallet is already connecting or connected");
}
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);
}
_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);
}
}
public void ShouldSyncBlockChainAgainstLocal()
{
var network = new TestNetwork();
network.AddSeed(new NetworkAddress(new IPEndPoint(IPAddress.Parse("192.168.2.101"), 9999)));
var p = new TestTransactionPool();
p.Add("t1", 1);
p.Add("t2", 0);
p.Spend("t2", "t1", 0);
p.Render();
var genesisBlock = new TestBlock(p.TakeOut("t1").Value);
var block1 = new TestBlock(p.TakeOut("t2").Value);
block1.Parent = genesisBlock;
genesisBlock.Render();
block1.Render();
WithBlockChains(1, genesisBlock.Value.Key, blockChains =>
{
// blockChains[0].HandleNewBlock(genesisBlock.Value.Value);
// blockChains[0].HandleNewBlock(block1.Value.Value);
AutoResetEvent waitForConnection = new AutoResetEvent(false);
bool connected = false;
blockChains[0].OnAddedToStore += transaction =>
{
Trace.Information("-- Transaction Received (node server)");
// actionReceiver();
};
AddressManager addressManager = new AddressManager();
addressManager.PeersToFind = 1;
NodeConnectionParameters nodesGroupParameters = new NodeConnectionParameters();
// nodesGroupParameters.AddressFrom = servers[1].ExternalEndpoint;
nodesGroupParameters.TemplateBehaviors.Add(new AddressManagerBehavior(addressManager));
nodesGroupParameters.TemplateBehaviors.Add(new ChainBehavior(blockChains[0]));
nodesGroupParameters.TemplateBehaviors.Add(new BroadcastHubBehavior());
nodesGroupParameters.TemplateBehaviors.Add(new SPVBehavior(blockChains[0], BroadcastHub.GetBroadcastHub(nodesGroupParameters.TemplateBehaviors)));
NodesGroup nodesGroup = new NodesGroup(network, nodesGroupParameters);
nodesGroup.AllowSameGroup = true;
nodesGroup.MaximumNodeConnection = 1;
nodesGroup.ConnectedNodes.Added += (object sender, NodeEventArgs e) =>
{
Trace.Information("-- Node added to node group");
connected = true;
waitForConnection.Set();
};
nodesGroup.Connect();
Assert.True(waitForConnection.WaitOne(10000)); //TODO: use reset events instead of sleep
Assert.True(connected);
//TODO
Thread.Sleep(40000);
// actionSender(BroadcastHub.GetBroadcastHub(nodesGroup.NodeConnectionParameters));
Trace.Information("-- Done");
});
}
public AddressItem Address([System.Web.Http.FromBody] AddressItem addressItem)
{
var address = new AddressManager();
return(address.Add(addressItem));
}
public static async Task InitializeNoWalletAsync()
{
WalletService = null;
ChaumianClient = null;
AddressManager = null;
TorManager = null;
#region ConfigInitialization
Config = new Config(Path.Combine(DataDir, "Config.json"));
await Config.LoadOrCreateDefaultFileAsync();
Logger.LogInfo <Config>("Config is successfully initialized.");
#endregion ConfigInitialization
BitcoinStore = new BitcoinStore();
var bstoreInitTask = BitcoinStore.InitializeAsync(Path.Combine(DataDir, "BitcoinStore"), Network);
var hwiInitTask = HwiProcessManager.InitializeAsync(DataDir, Network);
var addressManagerFolderPath = Path.Combine(DataDir, "AddressManager");
AddressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{Network}.dat");
var blocksFolderPath = Path.Combine(DataDir, $"Blocks{Network}");
var connectionParameters = new NodeConnectionParameters();
if (Config.UseTor.Value)
{
Synchronizer = new WasabiSynchronizer(Network, BitcoinStore, () => Config.GetCurrentBackendUri(), Config.GetTorSocks5EndPoint());
}
else
{
Synchronizer = new WasabiSynchronizer(Network, BitcoinStore, Config.GetFallbackBackendUri(), null);
}
UpdateChecker = new UpdateChecker(Synchronizer.WasabiClient);
#region ProcessKillSubscription
AppDomain.CurrentDomain.ProcessExit += async(s, e) => await TryDesperateDequeueAllCoinsAsync();
Console.CancelKeyPress += async(s, e) =>
{
e.Cancel = true;
Logger.LogWarning("Process was signaled for killing.", nameof(Global));
KillRequested = true;
await TryDesperateDequeueAllCoinsAsync();
Dispatcher.UIThread.PostLogException(() =>
{
Application.Current?.MainWindow?.Close();
});
};
#endregion ProcessKillSubscription
#region TorProcessInitialization
if (Config.UseTor.Value)
{
TorManager = new TorProcessManager(Config.GetTorSocks5EndPoint(), TorLogsFile);
}
else
{
TorManager = TorProcessManager.Mock();
}
TorManager.Start(false, DataDir);
var fallbackRequestTestUri = new Uri(Config.GetFallbackBackendUri(), "/api/software/versions");
TorManager.StartMonitor(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(7), DataDir, fallbackRequestTestUri);
Logger.LogInfo <TorProcessManager>($"{nameof(TorProcessManager)} is initialized.");
#endregion TorProcessInitialization
#region AddressManagerInitialization
var needsToDiscoverPeers = true;
if (Network == Network.RegTest)
{
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"Fake {nameof(AddressManager)} is initialized on the RegTest.");
}
else
{
try
{
AddressManager = AddressManager.LoadPeerFile(AddressManagerFilePath);
// The most of the times we don't need to discover new peers. Instead, we can connect to
// some of those that we already discovered in the past. In this case we assume that we
// assume that discovering new peers could be necessary if out address manager has less
// than 500 addresses. A 500 addresses could be okay because previously we tried with
// 200 and only one user reported he/she was not able to connect (there could be many others,
// of course).
// On the other side, increasing this number forces users that do not need to discover more peers
// to spend resources (CPU/bandwith) to discover new peers.
needsToDiscoverPeers = Config.UseTor == true || AddressManager.Count < 500;
Logger.LogInfo <AddressManager>($"Loaded {nameof(AddressManager)} from `{AddressManagerFilePath}`.");
}
catch (DirectoryNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (FileNotFoundException ex)
{
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} did not exist at `{AddressManagerFilePath}`. Initializing new one.");
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
}
catch (OverflowException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/712
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} has thrown `{nameof(OverflowException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} autocorrection is successful.");
}
catch (FormatException ex)
{
// https://github.com/zkSNACKs/WalletWasabi/issues/880
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} has thrown `{nameof(FormatException)}`. Attempting to autocorrect.");
File.Delete(AddressManagerFilePath);
Logger.LogTrace <AddressManager>(ex);
AddressManager = new AddressManager();
Logger.LogInfo <AddressManager>($"{nameof(AddressManager)} autocorrection is successful.");
}
}
var addressManagerBehavior = new AddressManagerBehavior(AddressManager)
{
Mode = needsToDiscoverPeers ? AddressManagerBehaviorMode.Discover : AddressManagerBehaviorMode.None
};
connectionParameters.TemplateBehaviors.Add(addressManagerBehavior);
#endregion AddressManagerInitialization
#region MempoolInitialization
MemPoolService = new MemPoolService();
connectionParameters.TemplateBehaviors.Add(new MemPoolBehavior(MemPoolService));
#endregion MempoolInitialization
#region HwiProcessInitialization
try
{
await hwiInitTask;
}
catch (Exception ex)
{
Logger.LogError(ex, nameof(Global));
}
#endregion HwiProcessInitialization
#region BitcoinStoreInitialization
await bstoreInitTask;
#endregion BitcoinStoreInitialization
#region P2PInitialization
if (Network == Network.RegTest)
{
Nodes = new NodesGroup(Network, requirements: Constants.NodeRequirements);
try
{
Node node = await Node.ConnectAsync(Network.RegTest, new IPEndPoint(IPAddress.Loopback, 18444));
Nodes.ConnectedNodes.Add(node);
RegTestMemPoolServingNode = await Node.ConnectAsync(Network.RegTest, new IPEndPoint(IPAddress.Loopback, 18444));
RegTestMemPoolServingNode.Behaviors.Add(new MemPoolBehavior(MemPoolService));
}
catch (SocketException ex)
{
Logger.LogError(ex, nameof(Global));
}
}
else
{
if (Config.UseTor is true)
{
// onlyForOnionHosts: false - Connect to clearnet IPs through Tor, too.
connectionParameters.TemplateBehaviors.Add(new SocksSettingsBehavior(Config.GetTorSocks5EndPoint(), onlyForOnionHosts: false, networkCredential: null, streamIsolation: true));
// allowOnlyTorEndpoints: true - Connect only to onions and don't connect to clearnet IPs at all.
// This of course makes the first setting unneccessary, but it's better if that's around, in case someone wants to tinker here.
connectionParameters.EndpointConnector = new DefaultEndpointConnector(allowOnlyTorEndpoints: Network == Network.Main);
await AddKnownBitcoinFullNodeAsHiddenServiceAsync(AddressManager);
}
Nodes = new NodesGroup(Network, connectionParameters, requirements: Constants.NodeRequirements);
RegTestMemPoolServingNode = null;
}
Nodes.Connect();
Logger.LogInfo("Start connecting to nodes...");
if (RegTestMemPoolServingNode != null)
{
RegTestMemPoolServingNode.VersionHandshake();
Logger.LogInfo("Start connecting to mempool serving regtest node...");
}
#endregion P2PInitialization
#region SynchronizerInitialization
var requestInterval = TimeSpan.FromSeconds(30);
if (Network == Network.RegTest)
{
requestInterval = TimeSpan.FromSeconds(5);
}
int maxFiltSyncCount = Network == Network.Main ? 1000 : 10000; // On testnet, filters are empty, so it's faster to query them together
Synchronizer.Start(requestInterval, TimeSpan.FromMinutes(5), maxFiltSyncCount);
Logger.LogInfo("Start synchronizing filters...");
#endregion SynchronizerInitialization
Initialized = true;
}
public String ApplyBudgetTemplate(Budget budget, Int32 budgetDocumentTemplateId)
{
var addressManager = new AddressManager(this);
DocumentTemplate documentTemplate = new CompanyManager(this).GetDocumentTemplate(budgetDocumentTemplateId);
string template = documentTemplate == null ? GetTempBudgetTemplate() : documentTemplate.Content;
bool isRtf = documentTemplate.FileName.EndsWith("rtf", StringComparison.OrdinalIgnoreCase);
var stringBuilder = new StringBuilder(template);
var tempStringBuilder = new StringBuilder();
if (budget.BudgetItems == null)
budget = GetBudget(budget.BudgetId, budget.CompanyId);
stringBuilder.Replace("[NumeroDoOrcamento]", budget.BudgetCode);
stringBuilder.Replace("[DataEmissao]", budget.ModifiedDate.ToShortDateString() +
(isRtf ? "<br />".ToRtf() : "<br />"));
//header with informations of current date
string header = budget.Company.LegalEntityProfile.Address.State + " , " + DateTime.Now.ToLongDateString().Split(',').ElementAt(1);
stringBuilder.Replace("[Cabecalho]", header);
#region CompanyInformations
stringBuilder.Replace("[NomeDaEmpresa]", budget.Company.LegalEntityProfile.CompanyName);
stringBuilder.Replace("[TelefoneDaEmpresa]", budget.Company.LegalEntityProfile.Phone);
stringBuilder.Replace("[Endereco-Empresa]", budget.Company.LegalEntityProfile.Address.Name.ToCapitalize());
stringBuilder.Replace("[Endereco-Complemento-Empresa]", String.Empty);
if (!String.IsNullOrEmpty(budget.Company.LegalEntityProfile.AddressComp))
stringBuilder.Replace("[Endereco-Complemento-Empresa]", budget.Company.LegalEntityProfile.AddressComp.ToCapitalize());
stringBuilder.Replace("[Endereco-Numero-Empresa]", budget.Company.LegalEntityProfile.AddressNumber);
stringBuilder.Replace("[Endereco-Cep-Empresa]", budget.Company.LegalEntityProfile.PostalCode);
stringBuilder.Replace("[Endereco-Cidade-Empresa]", budget.Company.LegalEntityProfile.Address.City.ToCapitalize());
stringBuilder.Replace("[Endereco-Estado-Empresa]", addressManager.GetAcronymState(budget.Company.LegalEntityProfile.Address.State));
stringBuilder.Replace("[Endereco-Bairro-Empresa]", budget.Company.LegalEntityProfile.Address.Neighborhood.ToCapitalize());
#endregion
//Customer
if (budget.CustomerId.HasValue || !String.IsNullOrEmpty(budget.CustomerName))
{
#region Customer Data
stringBuilder.Replace("[NomeDoCliente]", String.IsNullOrEmpty(budget.CustomerName)
? budget.Customer.Name
: budget.CustomerName);
stringBuilder.Replace("[EmailDoClente]", budget.Customer != null
? budget.Customer.Email
: budget.CustomerMail);
stringBuilder.Replace("[TelefoneDoCliente]", String.IsNullOrEmpty(budget.CustomerPhone)
? budget.Customer.Phone
: budget.CustomerPhone);
#endregion
if (budget.Customer != null)
{
#region Customer Address
if (budget.Customer.Address != null)
{
stringBuilder.Replace("[EnderecoDoCliente]", String.Empty);
if (!String.IsNullOrEmpty(budget.Customer.Address.Name))
stringBuilder.Replace("[EnderecoDoCliente]", budget.Customer.Address.Name.ToCapitalize());
stringBuilder.Replace("[Endereco-Complemento]", String.Empty);
if (!String.IsNullOrEmpty(budget.Customer.AddressComp))
stringBuilder.Replace("[Endereco-Complemento]", budget.Customer.AddressComp.ToCapitalize());
stringBuilder.Replace("[Endereco-Bairro]", String.Empty);
if (!String.IsNullOrEmpty(budget.Customer.Address.Neighborhood))
stringBuilder.Replace("[Endereco-Bairro]", budget.Customer.Address.Neighborhood.ToCapitalize());
stringBuilder.Replace("[Endereco-Cidade]", String.Empty);
if (!String.IsNullOrEmpty(budget.Customer.Address.City))
stringBuilder.Replace("[Endereco-Cidade]", budget.Customer.Address.City.ToCapitalize());
stringBuilder.Replace("[Endereco-Numero]", String.Empty);
if (!String.IsNullOrEmpty(budget.Customer.AddressNumber))
stringBuilder.Replace("[Endereco-Numero]", budget.Customer.AddressNumber);
stringBuilder.Replace("[Endereco-Cep]", String.Empty);
if (!String.IsNullOrEmpty(budget.Customer.Address.PostalCode))
stringBuilder.Replace("[Endereco-Cep]", budget.Customer.Address.PostalCode);
stringBuilder.Replace("[Endereco-Estado]", addressManager.GetAcronymState(budget.Company.LegalEntityProfile.Address.State));
}
#endregion
string phone2 = "", phone3 = "";
if (budget.Customer.LegalEntityProfile != null)
{
phone2 = budget.Customer.LegalEntityProfile.Phone2;
phone3 = budget.Customer.LegalEntityProfile.Phone3;
}
stringBuilder.Replace("[Telefone2]", phone2);
stringBuilder.Replace("[Telefone3]", phone3);
stringBuilder.Replace("[CNPJ]", budget.Customer.LegalEntityProfile != null
? "CNPJ: " + budget.Customer.LegalEntityProfile.CNPJ
: String.Empty);
stringBuilder.Replace("[CPF]", budget.Customer.Profile != null
? "CPF: " + budget.Customer.Profile.CPF
: String.Empty);
stringBuilder.Replace("[IE]", budget.Customer.LegalEntityProfile != null
? "IE: " + budget.Customer.LegalEntityProfile.IE
: String.Empty);
stringBuilder.Replace("[RG]", budget.Customer.Profile != null
? "RG: " + budget.Customer.Profile.RG
: String.Empty);
}
else
{
stringBuilder.Replace("[EnderecoDoCliente]", String.Empty);
stringBuilder.Replace("[Endereco-Complemento]", String.Empty);
stringBuilder.Replace("[Endereco-Numero]", String.Empty);
stringBuilder.Replace("[Endereco-Cep]", String.Empty);
stringBuilder.Replace("[Endereco-Cidade]", String.Empty);
stringBuilder.Replace("[Endereco-Estado]", String.Empty);
stringBuilder.Replace("[Telefone2]", String.Empty);
stringBuilder.Replace("[Telefone3]", String.Empty);
}
}
#region BudgetItems
tempStringBuilder = new StringBuilder();
//Header
//Body
Int32 itemCount = 0;
Decimal totalValue = Decimal.Zero;
foreach (BudgetItem item in GetBudgetItemByBudget(budget.BudgetId, budget.CompanyId))
{
itemCount++;
string itemName = item.SpecialProductName;
tempStringBuilder.AppendFormat(@"
<fieldset>
<table>
<tr>
<td style='white-space:nowrap; width:1%;' width='1%'>Código:</td>
<td class='code' colspan='2'>{0}</td>
</tr>
<tr>
<td style='white-space:nowrap'>Qtd:</td>
<td class='qtd' colspan='2'>{1}</td>
</tr>
<tr>
<td style='white-space:nowrap'>Desc:</td>
<td class='description' colspan='2'>{2}</td>
</tr>
<tr>
<td style='white-space:nowrap'>Vlr Unit:</td>
<td>{3}</td>
<td style='text-align:right'>Valor: {4}</td>
</tr>
</table>
</fieldset>", item.ProductCode + " | " + itemName,
item.Quantity,
item.ProductDescription,
item.UnitPrice.Value.ToString("c"),
(item.Quantity * item.UnitPrice.Value).ToString("c"));
totalValue += (item.Quantity * item.UnitPrice.Value);
}
// Subtotal
tempStringBuilder.AppendFormat(@"<table width='100%'><tr>
<td style='white-space:nowrap'><b>Subtotal (R$): </b></td>
<td style='white-space:nowrap; text-align:right'>{0}<td>
</tr>", totalValue);
// AdditionalCost
if (budget.AdditionalCost.HasValue)
{
tempStringBuilder.AppendFormat(@"<tr>
<td style='white-space:nowrap'><b>Adicional (R$): </b></td>
<td style='white-space:nowrap; text-align:right'>{0}<td>
</tr>", budget.AdditionalCost.Value.ToString("c"));
totalValue += budget.AdditionalCost.Value;
}
// Discount
if (budget.Discount.HasValue)
{
tempStringBuilder.AppendFormat(@"<tr>
<td style='white-space:nowrap'><b>Desconto (R$): </b></td>
<td style='white-space:nowrap; text-align:right'>{0}<td>
</tr>", budget.Discount.Value.ToString("c"));
totalValue -= budget.Discount.Value;
}
//Footer
tempStringBuilder.AppendFormat(@"<tr>
<td style='white-space:nowrap'><b>Valor Total da Proposta (R$): </b></td>
<td style='white-space:nowrap; text-align:right'> <b>{0}<b></td>
</tr>
<tr>
<td style='white-space:nowrap; text-align:center' colspan='2'><b>({1})<b></td>
</tr>
</table>", totalValue.ToString("c"), totalValue.AtFull().ToUpper());
stringBuilder.Replace("[Items]", isRtf ? tempStringBuilder.ToString().ToRtf() : tempStringBuilder.ToString());
stringBuilder.Replace("[TotalDaProposta]", totalValue.ToString());
stringBuilder.Replace("[ValorTotalPorExtenso]", totalValue.AtFull().ToUpper());
#endregion
#region Others
stringBuilder.Replace("[Contato]", budget.ContactName);
stringBuilder.Replace("[DataEntrega]", budget.DeliveryDate);
stringBuilder.Replace("[Garantia]", budget.Warranty);
stringBuilder.Replace("[Validade]", budget.ExpirationDate.ToString());
stringBuilder.Replace("[FormaPagamento]", budget.PaymentMethod);
stringBuilder.Replace("[Observacao]", budget.Observation);
stringBuilder.Replace("[Vendedor]", budget.Employee.Profile.AbreviatedName);
stringBuilder.Replace("[EmailVendedor]", budget.Employee.Profile.Email);
stringBuilder.Replace("[FormaEntrega]", budget.DeliveryDescription);
stringBuilder.Replace("[Pintura/Tratamento]", budget.Treatment);
#endregion
return stringBuilder.ToString();
}