Add blazor module

src/Catalyst.Cli/Program.cs

@@ -24,6 +24,7 @@
 using System;
 using System.Diagnostics;
 using System.IO;
+using System.Threading.Tasks;
 using Autofac;
 using Catalyst.Abstractions.Cli;
 using Catalyst.Core.Lib.Kernel;
@@ -59,26 +60,26 @@ public static int Main(string[] args)
             // Parse the arguments.
             Parser.Default
                 .ParseArguments<Options>(args)
-                .WithParsed(Run);
+                .WithParsed(o => _ = RunAsync(o));
 
             return Environment.ExitCode;
         }
 
-        private static void Run(Options options)
+        private static async Task RunAsync(Options options)
         {
             Kernel.Logger.Information("Catalyst.Cli started with process id {0}",
                 Process.GetCurrentProcess().Id.ToString());
 
             try
             {
-                Kernel.WithDataDirectory()
+                await Kernel.WithDataDirectory()
                     .WithSerilogConfigFile()
                     .WithConfigCopier(new CliConfigCopier())
                     .WithConfigurationFile(CliConstants.ShellNodesConfigFile)
                     .WithConfigurationFile(CliConstants.ShellConfigFile)
                     .WithNetworksConfigFile(NetworkType.Devnet, options.OverrideNetworkFile)
                     .BuildKernel()
-                    .StartCustom(StartCli);
+                    .StartCustomAsync(StartCliAsync);
 
                 Environment.ExitCode = 0;
             }
@@ -90,7 +91,7 @@ private static void Run(Options options)
         }
 
 
-        private static void StartCli(Kernel kernel)
+        private static Task StartCliAsync(Kernel kernel)
         {
             const int bufferSize = 1024 * 67 + 128;
 
@@ -110,6 +111,7 @@ private static void StartCli(Kernel kernel)
 
             kernel.Instance.Resolve<ICatalystCli>()
                 .RunConsole(kernel.CancellationTokenProvider.CancellationTokenSource.Token);
+            return Task.CompletedTask;
         }
     }
 }

src/Catalyst.Modules.Server.Blazor/App.razor

@@ -0,0 +1,10 @@
+<Router AppAssembly="@typeof(BlazorServerModule).Assembly">
+    <Found Context="routeData">
+        <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
+    </Found>
+    <NotFound>
+        <LayoutView Layout="@typeof(MainLayout)">
+            <p>Sorry, there's nothing at this address.</p>
+        </LayoutView>
+    </NotFound>
+</Router>

src/Catalyst.Modules.Server.Blazor/AutofacServiceProvider.cs

@@ -0,0 +1,128 @@
+using Autofac;
+using Autofac.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+
+namespace Catalyst.Modules.Server.Blazor
+{
+
+    /// <summary>
+    /// A factory for creating a <see cref="ContainerBuilder"/> and an <see cref="IServiceProvider" />.
+    /// </summary>
+    public class AutofacServiceProviderFactory : IServiceProviderFactory<ContainerBuilder>
+    {
+        private readonly ContainerBuilder _containerBuilder;
+        private AutofacServiceProvider _autofacServiceProvider;
+
+        public AutofacServiceProviderFactory(ContainerBuilder containerBuilder)
+        {
+            _containerBuilder = containerBuilder;
+        }
+
+        /// <summary>
+        /// Creates a container builder from an <see cref="IServiceCollection" />.
+        /// </summary>
+        /// <param name="services">The collection of services.</param>
+        /// <returns>A container builder that can be used to create an <see cref="IServiceProvider" />.</returns>
+        public ContainerBuilder CreateBuilder(IServiceCollection services)
+        {
+            _containerBuilder.Populate(services);
+            return _containerBuilder;
+        }
+
+        public void SetContainer(IContainer container)
+        {
+            _autofacServiceProvider.LifetimeScope = container;
+        }
+
+
+        /// <summary>
+        /// Creates an <see cref="IServiceProvider" /> from the container builder.
+        /// </summary>
+        /// <param name="containerBuilder">The container builder.</param>
+        /// <returns>An <see cref="IServiceProvider" />.</returns>
+        public IServiceProvider CreateServiceProvider(ContainerBuilder containerBuilder)
+        {
+            if (containerBuilder == null) throw new ArgumentNullException(nameof(containerBuilder));
+
+            return (_autofacServiceProvider = new AutofacServiceProvider());
+        }
+    }
+
+    /// <summary>
+    /// Autofac implementation of the ASP.NET Core <see cref="IServiceProvider"/>.
+    /// </summary>
+    /// <seealso cref="System.IServiceProvider" />
+    /// <seealso cref="Microsoft.Extensions.DependencyInjection.ISupportRequiredService" />
+    internal class AutofacServiceProvider : IServiceProvider, ISupportRequiredService, IDisposable
+    {
+        public ILifetimeScope LifetimeScope { get; set; }
+
+        private bool _disposed = false;
+
+        /// <summary>
+        /// Gets service of type <paramref name="serviceType" /> from the
+        /// <see cref="AutofacServiceProvider" /> and requires it be present.
+        /// </summary>
+        /// <param name="serviceType">
+        /// An object that specifies the type of service object to get.
+        /// </param>
+        /// <returns>
+        /// A service object of type <paramref name="serviceType" />.
+        /// </returns>
+        /// <exception cref="Autofac.Core.Registration.ComponentNotRegisteredException">
+        /// Thrown if the <paramref name="serviceType" /> isn't registered with the container.
+        /// </exception>
+        /// <exception cref="Autofac.Core.DependencyResolutionException">
+        /// Thrown if the object can't be resolved from the container.
+        /// </exception>
+        public object GetRequiredService(Type serviceType)
+        {
+            return LifetimeScope.Resolve(serviceType);
+        }
+
+        /// <summary>
+        /// Gets the service object of the specified type.
+        /// </summary>
+        /// <param name="serviceType">
+        /// An object that specifies the type of service object to get.
+        /// </param>
+        /// <returns>
+        /// A service object of type <paramref name="serviceType" />; or <see langword="null" />
+        /// if there is no service object of type <paramref name="serviceType" />.
+        /// </returns>
+        public object GetService(Type serviceType)
+        {
+            return LifetimeScope.ResolveOptional(serviceType);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing">
+        /// <see langword="true" /> to release both managed and unmanaged resources;
+        /// <see langword="false" /> to release only unmanaged resources.
+        /// </param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!this._disposed)
+            {
+                if (disposing)
+                {
+                    LifetimeScope.Dispose();
+                }
+
+                this._disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}

src/Catalyst.Modules.Server.Blazor/BlazorServerModule.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Diagnostics;
+using Autofac;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Module = Autofac.Module;
+
+namespace Catalyst.Modules.Server.Blazor
+{
+    public class BlazorServerModule : Module
+    {
+        public static void Main(string[] args) { }
+
+        private IHostBuilder _hostBuilder;
+        private AutofacServiceProviderFactory _autofacServiceProviderFactory;
+
+        protected override void Load(ContainerBuilder builder)
+        {
+            _autofacServiceProviderFactory = new AutofacServiceProviderFactory(builder);
+            _hostBuilder = CreateHostBuilder();
+            try
+            {
+                _hostBuilder.Build();
+            }
+            catch (Exception)
+            {
+                //Ignored exception as the server cannot start without container being built
+            }
+
+            builder.RegisterBuildCallback(Start);
+
+        }
+
+        private void Start(IContainer container)
+        {
+            _autofacServiceProviderFactory.SetContainer(container);
+            _ = container.Resolve<IHost>().RunAsync().ConfigureAwait(false);
+        }
+
+        public IHostBuilder CreateHostBuilder() =>
+            Host.CreateDefaultBuilder(null)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.Configure(Configure);
+                })
+                .UseServiceProviderFactory(_autofacServiceProviderFactory)
+                .ConfigureServices(ConfigureServices);
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app)
+        {
+            app.UseExceptionHandler("/Error");
+
+            // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
+            app.UseHsts();
+
+            app.UseHttpsRedirection();
+            app.UseStaticFiles();
+
+            app.UseRouting();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapBlazorHub();
+                endpoints.MapFallbackToPage("/_Host");
+            });
+        }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
+        public void ConfigureServices(IServiceCollection services)
+        {
+            var listener = new DiagnosticListener("Microsoft.AspNetCore");
+            services.AddSingleton(listener);
+            services.AddSingleton<DiagnosticSource>(listener);
+            services.AddRazorPages();
+            services.AddServerSideBlazor();
+        }
+    }
+}

src/Catalyst.Modules.Server.Blazor/Catalyst.Modules.Server.Blazor.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="wwwroot\css\bootstrap\bootstrap.min.css" />
+    <None Include="wwwroot\css\bootstrap\bootstrap.min.css.map" />
+    <None Include="wwwroot\css\open-iconic\FONT-LICENSE" />
+    <None Include="wwwroot\css\open-iconic\font\css\open-iconic-bootstrap.min.css" />
+    <None Include="wwwroot\css\open-iconic\font\fonts\open-iconic.eot" />
+    <None Include="wwwroot\css\open-iconic\font\fonts\open-iconic.otf" />
+    <None Include="wwwroot\css\open-iconic\font\fonts\open-iconic.svg" />
+    <None Include="wwwroot\css\open-iconic\font\fonts\open-iconic.ttf" />
+    <None Include="wwwroot\css\open-iconic\font\fonts\open-iconic.woff" />
+    <None Include="wwwroot\css\open-iconic\ICON-LICENSE" />
+    <None Include="wwwroot\css\open-iconic\README.md" />
+    <None Include="wwwroot\css\site.css" />
+    <None Include="wwwroot\favicon.ico" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Autofac" Version="4.8.1" />
+    <PackageReference Include="Autofac.Extensions.DependencyInjection" Version="4.3.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="$(ProjectDir)wwwroot\**" CopyToOutputDirectory="PreserveNewest" />
+
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\submodules\Catalyst.Node\src\Catalyst.Abstractions\Catalyst.Abstractions.csproj" />
+    <ProjectReference Include="..\..\submodules\Catalyst.Node\src\Catalyst.Core.Lib\Catalyst.Core.Lib.csproj" />
+  </ItemGroup>
+
+</Project>

src/Catalyst.Modules.Server.Blazor/Components/SendTransactionForm.razor

@@ -0,0 +1,12 @@
+@inherits SendTransactionFormBase
+
+<EditForm Model="@Model" OnValidSubmit="@HandleValidSubmit">
+    <DataAnnotationsValidator />
+    <ValidationSummary />
+    <p>
+        <label for="amount">Amount: </label>
+        <InputNumber @bind-Value="Model.Amount" />
+    </p>
+
+    <button type="submit">Submit</button>
+</EditForm>

src/Catalyst.Modules.Server.Blazor/Components/SendTransactionForm.razor.cs

@@ -0,0 +1,65 @@
+using Catalyst.Abstractions.IO.Events;
+using Catalyst.Abstractions.KeySigner;
+using Catalyst.Abstractions.P2P;
+using Catalyst.Core.Lib.Extensions;
+using Catalyst.Core.Lib.IO.Messaging.Correlation;
+using Catalyst.Modules.Server.Blazor.Models;
+using Catalyst.Protocol.Cryptography;
+using Catalyst.Protocol.Wire;
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+using Microsoft.AspNetCore.Components;
+using Microsoft.JSInterop;
+using System;
+using Catalyst.Core.Lib.Util;
+using Catalyst.Protocol.Transaction;
+
+namespace Catalyst.Modules.Server.Blazor.Components
+{
+    public class SendTransactionFormBase : ComponentBase
+    {
+        public SendTransactionModel Model { get; set; } = new SendTransactionModel();
+
+        [Inject]
+        public IJSRuntime JsRuntime { get; set; }
+
+        [Inject]
+        public IKeySigner KeySigner { get; set; }
+
+        [Inject]
+        public IPeerSettings PeerSettings { get; set; }
+
+        [Inject]
+        public ITransactionReceivedEvent TransactionReceivedEvent { get; set; }
+
+        public void HandleValidSubmit()
+        {
+            //TODO: Currently there is no method to actually set the transaction amount
+            var transaction = new TransactionBroadcast {Timestamp = Timestamp.FromDateTime(DateTime.UtcNow)};
+            transaction.PublicEntries.Add(new PublicEntry
+            {
+                Base = new BaseEntry
+                {
+                    SenderPublicKey = PeerSettings.PublicKey.KeyToByteString()
+                }
+            });
+            var signingContext = new SigningContext
+            {
+                NetworkType = PeerSettings.NetworkType,
+                SignatureType = SignatureType.ProtocolPeer
+            };
+
+            var signature = KeySigner.Sign(transaction.ToByteArray(), signingContext);
+            transaction.Signature = new Signature {
+                RawBytes = signature.SignatureBytes.ToByteString(), 
+                SigningContext = signingContext
+            };
+            var status = TransactionReceivedEvent
+                .OnTransactionReceived(transaction.ToProtocolMessage(PeerSettings.PeerId, CorrelationId.GenerateCorrelationId()));
+            JsRuntime.InvokeAsync<object>("window.alert", $"Transaction Status: {status.ToString()}").ConfigureAwait(false);
+            Model = new SendTransactionModel();
+            this.StateHasChanged();
+        }
+
+    }
+}