public RegTestFixture()
{
BackendNodeBuilder = NodeBuilder.CreateAsync(nameof(RegTestFixture)).GetAwaiter().GetResult();
BackendNodeBuilder.CreateNodeAsync().GetAwaiter().GetResult();
BackendNodeBuilder.StartAllAsync().GetAwaiter().GetResult();
BackendRegTestNode = BackendNodeBuilder.Nodes[0];
var rpc = BackendRegTestNode.CreateRpcClient();
var config = new Config(rpc.Network, rpc.Authentication, IPAddress.Loopback.ToString(), IPAddress.Loopback.ToString(), BackendRegTestNode.Endpoint.Address.ToString(), Network.Main.DefaultPort, Network.TestNet.DefaultPort, BackendRegTestNode.Endpoint.Port);
var roundConfig = new CcjRoundConfig(Money.Coins(0.1m), Constants.OneDayConfirmationTarget, 0.7, 0.1m, 100, 120, 60, 60, 60, 1, 24, true, 11);
Backend.Global.Instance.InitializeAsync(config, roundConfig, rpc).GetAwaiter().GetResult();
BackendEndPoint = $"http://localhost:{new Random().Next(37130, 38000)}/";
BackendHost = WebHost.CreateDefaultBuilder()
.UseStartup <Startup>()
.UseUrls(BackendEndPoint)
.Build();
var hostInitializationTask = BackendHost.RunAsync();
Logger.LogInfo($"Started Backend webhost: {BackendEndPoint}", nameof(Global));
var delayTask = Task.Delay(3000);
Task.WaitAny(delayTask, hostInitializationTask); // Wait for server to initialize (Without this OSX CI will fail)
}
public RegTestFixture()
{
BackendNodeBuilder = NodeBuilder.CreateAsync().GetAwaiter().GetResult();
BackendNodeBuilder.CreateNodeAsync().GetAwaiter().GetResult();
BackendNodeBuilder.StartAllAsync().GetAwaiter().GetResult();
BackendRegTestNode = BackendNodeBuilder.Nodes[0];
var rpc = BackendRegTestNode.CreateRpcClient();
var authString = rpc.Authentication.Split(':');
var config = new Config(rpc.Network, authString[0], authString[1]);
var roundConfig = new CcjRoundConfig(Money.Coins(0.1m), 144, 0.1m, 100, 120, 60, 60, 60, 1);
Global.InitializeAsync(config, roundConfig, rpc).GetAwaiter().GetResult();
BackendEndPoint = $"http://localhost:{new Random().Next(37130, 38000)}/";
BackendHost = WebHost.CreateDefaultBuilder()
.UseStartup <Startup>()
.UseUrls(BackendEndPoint)
.Build();
var hostInitializationTask = BackendHost.RunAsync();
Logger.LogInfo <SharedFixture>($"Started Backend webhost: {BackendEndPoint}");
var delayTask = Task.Delay(3000);
Task.WaitAny(delayTask, hostInitializationTask); // Wait for server to initialize (Without this OSX CI will fail)
}
public RegTestFixture()
{
BackendNodeBuilder = NodeBuilder.CreateAsync(EnvironmentHelpers.GetMethodName()).GetAwaiter().GetResult();
BackendNodeBuilder.CreateNodeAsync().GetAwaiter().GetResult();
BackendNodeBuilder.StartAllAsync().GetAwaiter().GetResult();
BackendRegTestNode = BackendNodeBuilder.Nodes[0];
var connectionString = $"{BackendRegTestNode.Creds.UserName}:{BackendRegTestNode.Creds.Password}";
var testnetBackendDir = EnvironmentHelpers.GetDataDir(Path.Combine("WalletWasabi", "Tests", "Backend"));
IoHelpers.DeleteRecursivelyWithMagicDustAsync(testnetBackendDir).GetAwaiter().GetResult();
Thread.Sleep(100);
Directory.CreateDirectory(testnetBackendDir);
Thread.Sleep(100);
var config = new Config(
BackendNodeBuilder.Network, connectionString,
new IPEndPoint(IPAddress.Loopback, Network.Main.DefaultPort),
new IPEndPoint(IPAddress.Loopback, Network.TestNet.DefaultPort),
BackendRegTestNode.P2pEndPoint,
new IPEndPoint(IPAddress.Loopback, Network.Main.RPCPort),
new IPEndPoint(IPAddress.Loopback, Network.TestNet.RPCPort),
BackendRegTestNode.RpcEndPoint);
var configFilePath = Path.Combine(testnetBackendDir, "Config.json");
config.SetFilePath(configFilePath);
config.ToFileAsync().GetAwaiter().GetResult();
var roundConfig = CreateRoundConfig(Money.Coins(0.1m), Constants.OneDayConfirmationTarget, 0.7, 0.1m, 100, 120, 60, 60, 60, 1, 24, true, 11);
var roundConfigFilePath = Path.Combine(testnetBackendDir, "CcjRoundConfig.json");
roundConfig.SetFilePath(roundConfigFilePath);
roundConfig.ToFileAsync().GetAwaiter().GetResult();
var conf = new ConfigurationBuilder()
.AddInMemoryCollection(new[] { new KeyValuePair <string, string>("datadir", testnetBackendDir) })
.Build();
BackendEndPoint = $"http://localhost:{new Random().Next(37130, 38000)}/";
BackendHost = WebHost.CreateDefaultBuilder()
.UseStartup <Startup>()
.UseConfiguration(conf)
.UseWebRoot("../../../../WalletWasabi.Backend/wwwroot")
.UseUrls(BackendEndPoint)
.Build();
Global = (Backend.Global)BackendHost.Services.GetService(typeof(Backend.Global));
var hostInitializationTask = BackendHost.RunWithTasksAsync();
Logger.LogInfo($"Started Backend webhost: {BackendEndPoint}");
var delayTask = Task.Delay(3000);
Task.WaitAny(delayTask, hostInitializationTask); // Wait for server to initialize (Without this OSX CI will fail)
}
public async Task CanWaitForNewBlockFromRpcAsync()
{
using (var builder = await NodeBuilder.CreateAsync())
{
var rpc = (await builder.CreateNodeAsync()).CreateRpcClient();
await builder.StartAllAsync();
var latestBlockTask = rpc.WaitForNewBlockAsync(2 * 1000); // wait for 2 seconds
var generatedBlock = builder.Nodes.First().Generate(1);
var latestBlock = await latestBlockTask;
Assert.True(latestBlockTask.IsCompleted && !latestBlockTask.IsFaulted);
Assert.Equal(generatedBlock[0].GetHash(), latestBlock.hash);
}
}
public async Task CanWaitForBlockFromRpcAsync()
{
using (var builder = await NodeBuilder.CreateAsync())
{
var rpc = (await builder.CreateNodeAsync()).CreateRpcClient();
await builder.StartAllAsync();
var generatedBlocks = builder.Nodes.First().Generate(10);
var latestBlockHash = generatedBlocks.Last().GetHash();
var latestBlockTask = rpc.WaitForBlockAsync(latestBlockHash);
builder.Nodes.First().BroadcastBlocks(generatedBlocks);
var latestBlock = await latestBlockTask;
Assert.True(latestBlockTask.IsCompleted && !latestBlockTask.IsFaulted);
Assert.Equal(latestBlockHash, latestBlock.hash);
}
}
public async Task FilterBuilderTestAsync()
{
using (var builder = await NodeBuilder.CreateAsync())
{
await builder.CreateNodeAsync();
await builder.StartAllAsync();
CoreNode regtestNode = builder.Nodes[0];
regtestNode.Generate(101);
RPCClient rpc = regtestNode.CreateRpcClient();
var indexBuilderServiceDir = Path.Combine(SharedFixture.DataDir, nameof(IndexBuilderService));
var indexFilePath = Path.Combine(indexBuilderServiceDir, $"Index{rpc.Network}.dat");
var utxoSetFilePath = Path.Combine(indexBuilderServiceDir, $"UtxoSet{rpc.Network}.dat");
var indexBuilderService = new IndexBuilderService(rpc, indexFilePath, utxoSetFilePath);
try
{
indexBuilderService.Synchronize();
// Test initial synchronization.
var times = 0;
uint256 firstHash = await rpc.GetBlockHashAsync(0);
while (indexBuilderService.GetFilterLinesExcluding(firstHash, 102, out _).filters.Count() != 101)
{
if (times > 500) // 30 sec
{
throw new TimeoutException($"{nameof(IndexBuilderService)} test timed out.");
}
await Task.Delay(100);
times++;
}
// Test later synchronization.
regtestNode.Generate(10);
times = 0;
while (indexBuilderService.GetFilterLinesExcluding(firstHash, 112, out bool found5).filters.Count() != 111)
{
Assert.True(found5);
if (times > 500) // 30 sec
{
throw new TimeoutException($"{nameof(IndexBuilderService)} test timed out.");
}
await Task.Delay(100);
times++;
}
// Test correct number of filters is received.
var hundredthHash = await rpc.GetBlockHashAsync(100);
Assert.Equal(11, indexBuilderService.GetFilterLinesExcluding(hundredthHash, 12, out bool found).filters.Count());
Assert.True(found);
var bestHash = await rpc.GetBestBlockHashAsync();
Assert.Empty(indexBuilderService.GetFilterLinesExcluding(bestHash, 1, out bool found2).filters);
Assert.True(found2);
Assert.Empty(indexBuilderService.GetFilterLinesExcluding(uint256.Zero, 1, out bool found3).filters);
Assert.False(found3);
// Test filter block hashes are correct.
var filters = indexBuilderService.GetFilterLinesExcluding(firstHash, 112, out bool found4).filters.ToArray();
Assert.True(found4);
for (int i = 0; i < 111; i++)
{
var expectedHash = await rpc.GetBlockHashAsync(i + 1);
var filterModel = FilterModel.FromLine(filters[i], i);
Assert.Equal(expectedHash, filterModel.BlockHash);
Assert.Null(filterModel.Filter);
}
}
finally
{
if (indexBuilderService != null)
{
await indexBuilderService.StopAsync();
}
}
}
}
