bump version

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -7,9 +7,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170720-02" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
     <PackageReference Include="xunit" Version="2.3.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
   </ItemGroup>
 
   <ItemGroup>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -106,19 +106,21 @@ namespace BTCPayServer.Tests
                     .UseStartup<Startup>()
                     .Build();
             _Host.Start();
-            Runtime = (BTCPayServerRuntime)_Host.Services.GetService(typeof(BTCPayServerRuntime));
-            var watcher = (InvoiceWatcher)_Host.Services.GetService(typeof(InvoiceWatcher));
-        }
+            InvoiceRepository = (InvoiceRepository)_Host.Services.GetService(typeof(InvoiceRepository));
 
-        public BTCPayServerRuntime Runtime
-        {
-            get; set;
+            var waiter = ((NBXplorerWaiterAccessor)_Host.Services.GetService(typeof(NBXplorerWaiterAccessor))).Instance;
+            while(waiter.State != NBXplorerState.Ready)
+            {
+                Thread.Sleep(10);
+            }
         }
+        
         public string HostName
         {
             get;
             internal set;
         }
+        public InvoiceRepository InvoiceRepository { get; private set; }
 
         public T GetService<T>()
         {

BTCPayServer.Tests/EclairTester.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Eclair;
+
+namespace BTCPayServer.Tests
+{
+    public class EclairTester
+    {
+        ServerTester parent;
+        public EclairTester(ServerTester parent, string environmentName, string defaultRPC, string defaultHost)
+        {
+            this.parent = parent;
+            RPC = new EclairRPCClient(new Uri(parent.GetEnvironment(environmentName, defaultRPC)), parent.Network);
+            P2PHost = parent.GetEnvironment(environmentName + "_HOST", defaultHost);
+        }
+
+        public EclairRPCClient RPC { get; }
+        public string P2PHost { get; }
+
+        NodeInfo _NodeInfo;
+        public async Task<NodeInfo> GetNodeInfoAsync()
+        {
+            if (_NodeInfo != null)
+                return _NodeInfo;
+            var info = await RPC.GetInfoAsync();
+            _NodeInfo = new NodeInfo(info.NodeId, P2PHost, info.Port);
+            return _NodeInfo;
+        }
+
+        public NodeInfo GetNodeInfo()
+        {
+            return GetNodeInfoAsync().GetAwaiter().GetResult();
+        }
+    }
+}

BTCPayServer.Tests/ServerTester.cs

@@ -1,4 +1,5 @@
 using BTCPayServer.Controllers;
+using System.Linq;
 using BTCPayServer.Models.AccountViewModels;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
@@ -16,6 +17,7 @@ using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 using System.Threading;
+using BTCPayServer.Eclair;
 
 namespace BTCPayServer.Tests
 {
@@ -56,9 +58,42 @@ namespace BTCPayServer.Tests
             PayTester.Port = int.Parse(GetEnvironment("TESTS_PORT", Utils.FreeTcpPort().ToString()));
             PayTester.HostName = GetEnvironment("TESTS_HOSTNAME", "127.0.0.1");
             PayTester.Start();
+
+            MerchantEclair = new EclairTester(this, "TEST_ECLAIR1", "http://127.0.0.1:30992/", "eclair1");
+            CustomerEclair = new EclairTester(this, "TEST_ECLAIR2", "http://127.0.0.1:30993/", "eclair2");
         }
 
-        private string GetEnvironment(string variable, string defaultValue)
+
+        /// <summary>
+        /// This will setup a channel going from customer to merchant
+        /// </summary>
+        public void PrepareLightning()
+        {
+            PrepareLightningAsync().GetAwaiter().GetResult();
+        }
+
+        public async Task PrepareLightningAsync()
+        {
+            // Activate segwit
+            var blockCount = ExplorerNode.GetBlockCountAsync();
+            // Fetch node info, but that in cache
+            var merchant = MerchantEclair.GetNodeInfoAsync();
+            var customer = CustomerEclair.GetNodeInfoAsync();
+            var channels = CustomerEclair.RPC.ChannelsAsync();
+            var connect = CustomerEclair.RPC.ConnectAsync(merchant.Result);
+            await Task.WhenAll(blockCount, merchant, customer, channels, connect);
+
+            // Mine until segwit is activated
+            if (blockCount.Result <= 432)
+            {
+                ExplorerNode.Generate(433 - blockCount.Result);
+            }
+        }
+
+        public EclairTester MerchantEclair { get; set; }
+        public EclairTester CustomerEclair { get; set; }
+
+        internal string GetEnvironment(string variable, string defaultValue)
         {
             var var = Environment.GetEnvironmentVariable(variable);
             return String.IsNullOrEmpty(var) ? defaultValue : var;
@@ -195,7 +230,7 @@ namespace BTCPayServer.Tests
                 var match = new TransactionMatch();
                 match.Outputs.Add(new KeyPathInformation() { ScriptPubKey = address.ScriptPubKey });
                 var content = new StringContent(new NBXplorer.Serializer(Network).ToString(match), new UTF8Encoding(false), "application/json");
-                var uri = controller.GetCallbackUriAsync(req).GetAwaiter().GetResult();
+                var uri = controller.GetCallbackUriAsync().GetAwaiter().GetResult();
 
                 HttpRequestMessage message = new HttpRequestMessage();
                 message.Method = HttpMethod.Post;
@@ -207,7 +242,7 @@ namespace BTCPayServer.Tests
             else
             {
 
-                var uri = controller.GetCallbackBlockUriAsync(req).GetAwaiter().GetResult();
+                var uri = controller.GetCallbackBlockUriAsync().GetAwaiter().GetResult();
                 HttpRequestMessage message = new HttpRequestMessage();
                 message.Method = HttpMethod.Post;
                 message.RequestUri = uri;

BTCPayServer.Tests/UnitTest1.cs

@@ -22,6 +22,7 @@ using BTCPayServer.Data;
 using Microsoft.EntityFrameworkCore;
 using BTCPayServer.Services.Rates;
 using Microsoft.Extensions.Caching.Memory;
+using BTCPayServer.Eclair;
 
 namespace BTCPayServer.Tests
 {
@@ -115,6 +116,24 @@ namespace BTCPayServer.Tests
             }
         }
 
+        [Fact]
+        public void CanUseLightMoney()
+        {
+            var light = LightMoney.MilliSatoshis(1);
+            Assert.Equal("0.00000000001", light.ToString());
+        }
+
+        [Fact]
+        public void CanSendLightningPayment()
+        {
+
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                tester.PrepareLightning();
+            }
+        }
+
         [Fact]
         public void CanUseServerInitiatedPairingCode()
         {
@@ -288,13 +307,13 @@ namespace BTCPayServer.Tests
 
                 Eventually(() =>
                 {
-                    var textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
+                    var textSearchResult = tester.PayTester.InvoiceRepository.GetInvoices(new InvoiceQuery()
                     {
                         StoreId = user.StoreId,
                         TextSearch = invoice.OrderId
                     }).GetAwaiter().GetResult();
                     Assert.Equal(1, textSearchResult.Length);
-                    textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
+                    textSearchResult = tester.PayTester.InvoiceRepository.GetInvoices(new InvoiceQuery()
                     {
                         StoreId = user.StoreId,
                         TextSearch = invoice.Id

BTCPayServer.Tests/docker-compose.yml

@@ -1,5 +1,8 @@
 version: "3"
 
+# Run `docker-compose up dev` for bootstrapping your development environment
+# Doing so will expose eclair API, NBXplorer, Bitcoind RPC and postgres port to the host so that tests can Run,
+# The Visual Studio launch setting `Docker-Regtest` is configured to use this environment.
 services:
 
   tests:
@@ -10,18 +13,36 @@ services:
       TESTS_RPCCONNECTION: server=http://bitcoind:43782;ceiwHEbqWI83:DwubwWsoo3
       TESTS_NBXPLORERURL: http://nbxplorer:32838/
       TESTS_POSTGRES: User ID=postgres;Host=postgres;Port=5432;Database=btcpayserver
-      TESTS_FAKECALLBACK: 'true'
+      TESTS_FAKECALLBACK: 'false'
       TESTS_PORT: 80
       TESTS_HOSTNAME: tests
+      TEST_ECLAIR1: http://eclair1:8080/
+      TEST_ECLAIR2: http://eclair2:8080/
     expose:
       - "80"
     links:
+      - bitcoind
       - nbxplorer
+      - eclair1
+      - eclair2
     extra_hosts: 
       - "tests:127.0.0.1"
 
+  # The dev container is not actually used, it is just handy to run `docker-compose up dev` to start all services
+  dev: 
+    image: nicolasdorier/docker-bitcoin:0.15.0.1
+    environment:
+      BITCOIN_EXTRA_ARGS: |
+        regtest=1
+        connect=bitcoind:39388
+    links:
+      - bitcoind
+      - nbxplorer
+      - eclair1
+      - eclair2
+
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.0.29
+    image: nicolasdorier/nbxplorer:1.0.0.32
     ports:
       - "32838:32838"
     expose: 
@@ -39,28 +60,73 @@ services:
       - bitcoind
       - postgres
 
-  eclair:
-    image: nicolasdorier/docker-bitcoin:0.15.0.1
+  eclair1:
+    image: acinq/eclair:latest
+    environment:
+      JAVA_OPTS: >
+        -Xmx512m 
+        -Declair.printToConsole 
+        -Declair.bitcoind.host=bitcoind 
+        -Declair.bitcoind.rpcport=43782 
+        -Declair.bitcoind.rpcuser=ceiwHEbqWI83 
+        -Declair.bitcoind.rpcpassword=DwubwWsoo3 
+        -Declair.bitcoind.zmq=tcp://bitcoind:29000
+        -Declair.chain=regtest
+        -Declair.api.binding-ip=0.0.0.0
+    links:
+      - bitcoind
+    ports:
+      - "30992:8080" # api port
+    expose:
+      - "9735" # server port
+      - "8080" # api port
+
+  eclair2:
+    image: acinq/eclair:latest
+    environment:
+      JAVA_OPTS: >
+        -Xmx512m 
+        -Declair.printToConsole 
+        -Declair.bitcoind.host=bitcoind 
+        -Declair.bitcoind.rpcport=43782 
+        -Declair.bitcoind.rpcuser=ceiwHEbqWI83 
+        -Declair.bitcoind.rpcpassword=DwubwWsoo3 
+        -Declair.bitcoind.zmq=tcp://bitcoind:29000
+        -Declair.chain=regtest
+        -Declair.api.binding-ip=0.0.0.0
+    links:
+      - bitcoind
+    ports:
+      - "30993:8080" # api port
+    expose:
+      - "9735" # server port
+      - "8080" # api port
 
   bitcoind:
     container_name: btcpayserver_dev_bitcoind
     image: nicolasdorier/docker-bitcoin:0.15.0.1
-    ports:
-      - "43782:43782"
-      - "39388:39388"
     environment:
       BITCOIN_EXTRA_ARGS: |
         rpcuser=ceiwHEbqWI83
         rpcpassword=DwubwWsoo3
         regtest=1
+        server=1
         rpcport=43782
         port=39388
         whitelist=0.0.0.0/0
+        zmqpubrawblock=tcp://0.0.0.0:29000
+        zmqpubrawtx=tcp://0.0.0.0:29000
+        txindex=1
+    ports:
+      - "43782:43782" # RPC
     expose:
-      - "43782"
-      - "39388"
+      - "43782" # RPC
+      - "39388" # P2P
+      - "29000" # zmq
 
   postgres:
     image:  postgres:9.6.5
     ports:
       - "39372:5432"
+    expose:
+      - "5432"

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.0.38</Version>
+		<Version>1.0.0.45</Version>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />
@@ -18,13 +18,13 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Hangfire" Version="1.6.17" />
-    <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.1" />
+    <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.2" />
     <PackageReference Include="Hangfire.PostgreSql" Version="1.4.8.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
-    <PackageReference Include="NBitcoin" Version="4.0.0.48" />
+    <PackageReference Include="NBitcoin" Version="4.0.0.50" />
     <PackageReference Include="NBitpayClient" Version="1.0.0.13" />	  
     <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.0.18" />
+    <PackageReference Include="NBXplorer.Client" Version="1.0.0.20" />
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.1" />
     <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.2" />
     <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.13" />
@@ -34,9 +34,9 @@
   </ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.0" />
-		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.0" PrivateAssets="All" />
-		<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.0" PrivateAssets="All" />
+		<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.3" />
+		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.1" PrivateAssets="All" />
+		<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.1" PrivateAssets="All" />
 	</ItemGroup>
 
 	<ItemGroup>

BTCPayServer/CompositeDisposable.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer
+{
+    public class CompositeDisposable : IDisposable
+    {
+        List<IDisposable> _Disposables = new List<IDisposable>();
+        public void Add(IDisposable disposable) { _Disposables.Add(disposable); }
+        public void Dispose()
+        {
+            foreach (var d in _Disposables)
+                d.Dispose();
+            _Disposables.Clear();
+        }
+    }
+}

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -55,14 +55,9 @@ namespace BTCPayServer.Configuration
 
             Explorer = conf.GetOrDefault<Uri>("explorer.url", networkInfo.DefaultExplorerUrl);
             CookieFile = conf.GetOrDefault<string>("explorer.cookiefile", networkInfo.DefaultExplorerCookieFile);
-            RequireHttps = conf.GetOrDefault<bool>("requirehttps", false);
             PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
             ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
-        }
-
-        public bool RequireHttps
-        {
-            get; set;
+            InternalUrl = conf.GetOrDefault<Uri>("internalurl", null);
         }
         public string PostgresConnectionString
         {
@@ -74,5 +69,6 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
+        public Uri InternalUrl { get; private set; }
     }
 }

BTCPayServer/Configuration/BTCPayServerRuntime.cs

@@ -1,110 +0,0 @@
-using BTCPayServer.Authentication;
-using Microsoft.Extensions.Logging;
-using BTCPayServer.Logging;
-using DBreeze;
-using NBitcoin;
-using NBXplorer;
-using NBXplorer.DerivationStrategy;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.EntityFrameworkCore;
-using BTCPayServer.Data;
-using BTCPayServer.Services.Invoices;
-using BTCPayServer.Services.Wallets;
-
-namespace BTCPayServer.Configuration
-{
-    public class BTCPayServerRuntime : IDisposable
-    {
-        public ExplorerClient Explorer
-        {
-            get;
-            private set;
-        }
-
-        public void Configure(BTCPayServerOptions opts)
-        {
-            ConfigureAsync(opts).GetAwaiter().GetResult();
-        }
-        public async Task ConfigureAsync(BTCPayServerOptions opts)
-        {
-            Network = opts.Network;
-            Explorer = new ExplorerClient(opts.Network, opts.Explorer);
-
-            if (!Explorer.SetCookieAuth(opts.CookieFile))
-                Explorer.SetNoAuth();
-
-            CancellationTokenSource cts = new CancellationTokenSource(30000);
-            try
-            {
-                Logs.Configuration.LogInformation("Trying to connect to explorer " + Explorer.Address.AbsoluteUri);
-                await Explorer.WaitServerStartedAsync(cts.Token).ConfigureAwait(false);
-                Logs.Configuration.LogInformation("Connection successfull");
-            }
-            catch (Exception ex)
-            {
-                throw new ConfigException($"Could not connect to NBXplorer, {ex.Message}");
-            }
-
-            ApplicationDbContextFactory dbContext = null;
-            if (opts.PostgresConnectionString == null)
-            {
-                var connStr = "Data Source=" + Path.Combine(opts.DataDir, "sqllite.db");
-                Logs.Configuration.LogInformation($"SQLite DB used ({connStr})");
-                dbContext = new ApplicationDbContextFactory(DatabaseType.Sqlite, connStr);
-            }
-            else
-            {
-                Logs.Configuration.LogInformation($"Postgres DB used ({opts.PostgresConnectionString})");
-                dbContext = new ApplicationDbContextFactory(DatabaseType.Postgres, opts.PostgresConnectionString);
-            }
-            DBFactory = dbContext;
-
-            InvoiceRepository = new InvoiceRepository(dbContext, CreateDBPath(opts, "InvoiceDB"), Network);
-            _Resources.Add(InvoiceRepository);
-        }
-
-        private static string CreateDBPath(BTCPayServerOptions opts, string name)
-        {
-            var dbpath = Path.Combine(opts.DataDir, name);
-            if (!Directory.Exists(dbpath))
-                Directory.CreateDirectory(dbpath);
-            return dbpath;
-        }
-
-        List<IDisposable> _Resources = new List<IDisposable>();
-
-        public void Dispose()
-        {
-            lock (_Resources)
-            {
-                foreach (var r in _Resources)
-                {
-                    r.Dispose();
-                }
-                _Resources.Clear();
-            }
-        }
-
-        public Network Network
-        {
-            get;
-            private set;
-        }
-        public InvoiceRepository InvoiceRepository
-        {
-            get;
-            set;
-        }
-        public ApplicationDbContextFactory DBFactory
-        {
-            get;
-            set;
-        }
-    }
-
-}

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -26,11 +26,11 @@ namespace BTCPayServer.Configuration
             app.Option("-n | --network", $"Set the network among ({NetworkInformation.ToStringAll()}) (default: {Network.Main.ToString()})", CommandOptionType.SingleValue);
             app.Option("--testnet | -testnet", $"Use testnet", CommandOptionType.BoolValue);
             app.Option("--regtest | -regtest", $"Use regtest", CommandOptionType.BoolValue);
-            app.Option("--requirehttps", $"Will redirect to https version of the website (default: false)", CommandOptionType.BoolValue);
             app.Option("--postgres", $"Connection string to postgres database (default: sqlite is used)", CommandOptionType.SingleValue);
             app.Option("--explorerurl", $"Url of the NBxplorer (default: : Default setting of NBXplorer for the network)", CommandOptionType.SingleValue);
             app.Option("--explorercookiefile", $"Path to the cookie file (default: Default setting of NBXplorer for the network)", CommandOptionType.SingleValue);
-            app.Option("--externalurl", $"The expected external url of this service, use if BTCPay is behind a reverse proxy (default: empty, use the incoming HTTP request to figure out)", CommandOptionType.SingleValue);
+            app.Option("--externalurl", $"The expected external url of this service, to use if BTCPay is behind a reverse proxy (default: empty, use the incoming HTTP request to figure out)", CommandOptionType.SingleValue);
+            app.Option("--internalurl", $"The expected internal url of this service, this set NBXplorer callback addresses (default: empty, use the incoming HTTP request to figure out)", CommandOptionType.SingleValue);
             return app;
         }
 
@@ -77,7 +77,6 @@ namespace BTCPayServer.Configuration
             builder.AppendLine("#regtest=0");
             builder.AppendLine();
             builder.AppendLine("### Server settings ###");
-            builder.AppendLine("#requirehttps=0");
             builder.AppendLine("#port=" + network.DefaultPort);
             builder.AppendLine("#bind=127.0.0.1");
             builder.AppendLine();

BTCPayServer/Controllers/CallbackController.cs

@@ -15,6 +15,11 @@ using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using BTCPayServer.Configuration;
+using BTCPayServer.Events;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Hosting.Server.Features;
+using Microsoft.AspNetCore.Hosting.Server;
 
 namespace BTCPayServer.Controllers
 {
@@ -29,18 +34,23 @@ namespace BTCPayServer.Controllers
         }
         SettingsRepository _Settings;
         Network _Network;
-        InvoiceWatcher _Watcher;
         ExplorerClient _Explorer;
-
+        BTCPayServerOptions _Options;
+        EventAggregator _EventAggregator;
+        IServer _Server;
         public CallbackController(SettingsRepository repo,
                                   ExplorerClient explorer,
-                                  InvoiceWatcher watcher,
+                                  EventAggregator eventAggregator,
+                                  BTCPayServerOptions options,
+                                  IServer server,
                                   Network network)
         {
             _Settings = repo;
             _Network = network;
-            _Watcher = watcher;
             _Explorer = explorer;
+            _Options = options;
+            _EventAggregator = eventAggregator;
+            _Server = server;
         }
 
         [Route("callbacks/transactions")]
@@ -48,7 +58,6 @@ namespace BTCPayServer.Controllers
         public async Task NewTransaction(string token)
         {
             await AssertToken(token);
-            Logs.PayServer.LogInformation("New transaction callback");
             //We don't want to register all the json converter at MVC level, so we parse here
             var serializer = new NBXplorer.Serializer(_Network);
             var content = await new StreamReader(Request.Body, new UTF8Encoding(false), false, 1024, true).ReadToEndAsync();
@@ -56,7 +65,10 @@ namespace BTCPayServer.Controllers
 
             foreach (var output in match.Outputs)
             {
-                await _Watcher.NotifyReceived(output.ScriptPubKey);
+                var evt = new TxOutReceivedEvent();
+                evt.ScriptPubKey = output.ScriptPubKey;
+                evt.Address = output.ScriptPubKey.GetDestinationAddress(_Network);
+                _EventAggregator.Publish(evt);
             }
         }
 
@@ -65,8 +77,7 @@ namespace BTCPayServer.Controllers
         public async Task NewBlock(string token)
         {
             await AssertToken(token);
-            Logs.PayServer.LogInformation("New block callback");
-            await _Watcher.NotifyBlock();
+            _EventAggregator.Publish(new NewBlockEvent());
         }
 
         private async Task AssertToken(string token)
@@ -76,15 +87,15 @@ namespace BTCPayServer.Controllers
                 throw new BTCPayServer.BitpayHttpException(400, "invalid-callback-token");
         }
 
-        public async Task<Uri> GetCallbackUriAsync(HttpRequest request)
+        public async Task<Uri> GetCallbackUriAsync()
         {
             string token = await GetToken();
-            return new Uri(request.GetAbsoluteRoot() + "/callbacks/transactions?token=" + token);
+            return BuildCallbackUri("callbacks/transactions?token=" + token);
         }
 
-        public async Task RegisterCallbackUriAsync(DerivationStrategyBase derivationScheme, HttpRequest request)
+        public async Task RegisterCallbackUriAsync(DerivationStrategyBase derivationScheme)
         {
-            var uri = await GetCallbackUriAsync(request);
+            var uri = await GetCallbackUriAsync();
             await _Explorer.SubscribeToWalletAsync(uri, derivationScheme);
         }
 
@@ -100,15 +111,31 @@ namespace BTCPayServer.Controllers
             return token;
         }
 
-        public async Task<Uri> GetCallbackBlockUriAsync(HttpRequest request)
+        public async Task<Uri> GetCallbackBlockUriAsync()
         {
             string token = await GetToken();
-            return new Uri(request.GetAbsoluteRoot() + "/callbacks/blocks?token=" + token);
+            return BuildCallbackUri("callbacks/blocks?token=" + token);
         }
 
-        public async Task<Uri> RegisterCallbackBlockUriAsync(HttpRequest request)
+        private Uri BuildCallbackUri(string callbackPath)
+        {
+            var address = _Server.Features.Get<IServerAddressesFeature>().Addresses
+                                 .Select(c => new Uri(TransformToRoutable(c)))
+                                 .First();
+            var baseUrl = _Options.InternalUrl == null ? address.AbsoluteUri : _Options.InternalUrl.AbsoluteUri;
+            baseUrl = baseUrl.WithTrailingSlash();
+            return new Uri(baseUrl + callbackPath);
+        }
+
+        private string TransformToRoutable(string host)
+        {
+            if (host.StartsWith("http://0.0.0.0"))
+                host = host.Replace("http://0.0.0.0", "http://127.0.0.1");
+            return host;
+        }
+
+        public async Task<Uri> RegisterCallbackBlockUriAsync(Uri uri)
         {
-            var uri = await GetCallbackBlockUriAsync(request);
             await _Explorer.SubscribeToBlocksAsync(uri);
             return uri;
         }

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -16,12 +16,14 @@ using System.Security.Claims;
 using System.Text;
 using System.Threading.Tasks;
 using BTCPayServer.Services.Rates;
+using System.Net.WebSockets;
+using System.Threading;
+using BTCPayServer.Events;
 
 namespace BTCPayServer.Controllers
 {
     public partial class InvoiceController
     {
-
         [HttpPost]
         [Route("invoices/{invoiceId}")]
         public IActionResult Invoice(string invoiceId, string command)
@@ -169,6 +171,73 @@ namespace BTCPayServer.Controllers
             return Json(model);
         }
 
+        [HttpGet]
+        [Route("i/{invoiceId}/status/ws")]
+        public async Task<IActionResult> GetStatusWebSocket(string invoiceId)
+        {
+            if (!HttpContext.WebSockets.IsWebSocketRequest)
+                return NotFound();
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            if (invoice == null || invoice.Status == "complete" || invoice.Status == "invalid" || invoice.Status == "expired")
+                return NotFound();
+            var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
+            CompositeDisposable leases = new CompositeDisposable();
+            try
+            {
+                _EventAggregator.Subscribe<Events.InvoiceDataChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId));
+                _EventAggregator.Subscribe<Events.InvoicePaymentEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId));
+                _EventAggregator.Subscribe<Events.InvoiceStatusChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId));
+                while (true)
+                {
+                    var message = await webSocket.ReceiveAsync(DummyBuffer, default(CancellationToken));
+                    if (message.MessageType == WebSocketMessageType.Close)
+                        break;
+                }
+            }
+            finally
+            {
+                leases.Dispose();
+                await CloseSocket(webSocket);
+            }
+            return new NoResponse();
+        }
+
+        class NoResponse : IActionResult
+        {
+            public Task ExecuteResultAsync(ActionContext context)
+            {
+                return Task.CompletedTask;
+            }
+        }
+
+        ArraySegment<Byte> DummyBuffer = new ArraySegment<Byte>(new Byte[1]);
+        private async Task NotifySocket(WebSocket webSocket, string invoiceId, string expectedId)
+        {
+            if (invoiceId != expectedId || webSocket.State != WebSocketState.Open)
+                return;
+            CancellationTokenSource cts = new CancellationTokenSource();
+            cts.CancelAfter(5000);
+            try
+            {
+                await webSocket.SendAsync(DummyBuffer, WebSocketMessageType.Binary, true, cts.Token);
+            }
+            catch { await CloseSocket(webSocket); }
+        }
+
+        private static async Task CloseSocket(WebSocket webSocket)
+        {
+            try
+            {
+                if (webSocket.State == WebSocketState.Open)
+                {
+                    CancellationTokenSource cts = new CancellationTokenSource();
+                    cts.CancelAfter(5000);
+                    await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", cts.Token);
+                }
+            }
+            finally { webSocket.Dispose(); }
+        }
+
         [HttpPost]
         [Route("i/{invoiceId}/UpdateCustomer")]
         public async Task<IActionResult> UpdateCustomer(string invoiceId, [FromBody]UpdateCustomerModel data)

BTCPayServer/Controllers/InvoiceController.cs

@@ -53,7 +53,7 @@ namespace BTCPayServer.Controllers
         IFeeProvider _FeeProvider;
         private CurrencyNameTable _CurrencyNameTable;
         ExplorerClient _Explorer;
-
+        EventAggregator _EventAggregator;
         public InvoiceController(
             Network network,
             InvoiceRepository invoiceRepository,
@@ -62,7 +62,8 @@ namespace BTCPayServer.Controllers
             BTCPayWallet wallet,
             IRateProvider rateProvider,
             StoreRepository storeRepository,
-            InvoiceWatcher watcher,
+            EventAggregator eventAggregator,
+            InvoiceWatcherAccessor watcher,
             ExplorerClient explorerClient,
             IFeeProvider feeProvider)
         {
@@ -73,9 +74,10 @@ namespace BTCPayServer.Controllers
             _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
             _Wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
             _RateProvider = rateProvider ?? throw new ArgumentNullException(nameof(rateProvider));
-            _Watcher = watcher ?? throw new ArgumentNullException(nameof(watcher));
+            _Watcher = (watcher ?? throw new ArgumentNullException(nameof(watcher))).Instance;
             _UserManager = userManager;
             _FeeProvider = feeProvider ?? throw new ArgumentNullException(nameof(feeProvider));
+            _EventAggregator = eventAggregator;
         }
 
         internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl, double expiryMinutes = 15)

BTCPayServer/Controllers/StoresController.cs

@@ -198,7 +198,8 @@ namespace BTCPayServer.Controllers
                         {
                             var strategy = ParseDerivationStrategy(model.DerivationScheme, model.DerivationSchemeFormat);
                             await _Wallet.TrackAsync(strategy);
-                            await _CallbackController.RegisterCallbackUriAsync(strategy, Request);
+                            await _CallbackController.RegisterCallbackUriAsync(strategy);
+                            model.DerivationScheme = strategy.ToString();
                         }
                         store.DerivationStrategy = model.DerivationScheme;
                     }
@@ -275,12 +276,12 @@ namespace BTCPayServer.Controllers
                 var prefix = Utils.ToUInt32(data, false);
                 if (!electrumMapping.TryGetValue(prefix, out string[] labels))
                     throw new FormatException("!electrumMapping.TryGetValue(prefix, out string[] labels)");
-                var standardPrefix = Utils.ToBytes(standard, false);
+                var standardPrefix = Utils.ToBytes(_Network == Network.Main ? 0x0488b21eU : 0x043587cf, false);
 
                 for (int i = 0; i < 4; i++)
                     data[i] = standardPrefix[i];
 
-                derivationScheme = new BitcoinExtPubKey(Encoders.Base58Check.EncodeData(data), Network.Main).ToNetwork(_Network).ToString();
+                derivationScheme = new BitcoinExtPubKey(Encoders.Base58Check.EncodeData(data), _Network).ToString();
                 foreach (var label in labels)
                 {
                     derivationScheme = derivationScheme + $"-[{label}]";

BTCPayServer/Eclair/AllChannelResponse.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Eclair
+{
+    public class AllChannelResponse
+    {
+        public string ShortChannelId { get; set; }
+        public string NodeId1 { get; set; }
+        public string NodeId2 { get; set; }
+    }
+}

BTCPayServer/Eclair/ChannelResponse.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Eclair
+{
+    public class ChannelResponse
+    {
+
+        public string NodeId { get; set; }
+        public string ChannelId { get; set; }
+        public string State { get; set; }
+    }
+    public static class ChannelStates
+    {
+        public const string WAIT_FOR_FUNDING_CONFIRMED = "WAIT_FOR_FUNDING_CONFIRMED";
+
+        public const string NORMAL = "NORMAL";
+    }
+}

BTCPayServer/Eclair/EclairRPCClient.cs

@@ -0,0 +1,230 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBitcoin.JsonConverters;
+using NBitcoin.RPC;
+
+namespace BTCPayServer.Eclair
+{
+    public class EclairRPCClient
+    {
+        public EclairRPCClient(Uri address, Network network)
+        {
+            if (address == null)
+                throw new ArgumentNullException(nameof(address));
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            Address = address;
+            Network = network;
+        }
+
+        public Network Network { get; private set; }
+
+
+        public GetInfoResponse GetInfo()
+        {
+            return GetInfoAsync().GetAwaiter().GetResult();
+        }
+
+        public Task<GetInfoResponse> GetInfoAsync()
+        {
+            return SendCommandAsync<GetInfoResponse>(new RPCRequest("getinfo", new object[] { }));
+        }
+
+        public async Task<T> SendCommandAsync<T>(RPCRequest request, bool throwIfRPCError = true)
+        {
+            var response = await SendCommandAsync(request, throwIfRPCError);
+            return Serializer.ToObject<T>(response.ResultString, Network);
+        }
+
+        public async Task<RPCResponse> SendCommandAsync(RPCRequest request, bool throwIfRPCError = true)
+        {
+            RPCResponse response = null;
+            HttpWebRequest webRequest = response == null ? CreateWebRequest() : null;
+            if (response == null)
+            {
+                var writer = new StringWriter();
+                request.WriteJSON(writer);
+                writer.Flush();
+                var json = writer.ToString();
+                var bytes = Encoding.UTF8.GetBytes(json);
+#if !(PORTABLE || NETCORE)
+                webRequest.ContentLength = bytes.Length;
+#endif
+                var dataStream = await webRequest.GetRequestStreamAsync().ConfigureAwait(false);
+                await dataStream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
+                await dataStream.FlushAsync().ConfigureAwait(false);
+                dataStream.Dispose();
+            }
+            WebResponse webResponse = null;
+            WebResponse errorResponse = null;
+            try
+            {
+                webResponse = response == null ? await webRequest.GetResponseAsync().ConfigureAwait(false) : null;
+                response = response ?? RPCResponse.Load(await ToMemoryStreamAsync(webResponse.GetResponseStream()).ConfigureAwait(false));
+
+                if (throwIfRPCError)
+                    response.ThrowIfError();
+            }
+            catch (WebException ex)
+            {
+                if (ex.Response == null || ex.Response.ContentLength == 0 ||
+                    !ex.Response.ContentType.Equals("application/json", StringComparison.Ordinal))
+                    throw;
+                errorResponse = ex.Response;
+                response = RPCResponse.Load(await ToMemoryStreamAsync(errorResponse.GetResponseStream()).ConfigureAwait(false));
+                if (throwIfRPCError)
+                    response.ThrowIfError();
+            }
+            finally
+            {
+                if (errorResponse != null)
+                {
+                    errorResponse.Dispose();
+                    errorResponse = null;
+                }
+                if (webResponse != null)
+                {
+                    webResponse.Dispose();
+                    webResponse = null;
+                }
+            }
+            return response;
+        }
+
+        public AllChannelResponse[] AllChannels()
+        {
+            return AllChannelsAsync().GetAwaiter().GetResult();
+        }
+
+        public async Task<AllChannelResponse[]> AllChannelsAsync()
+        {
+            return await SendCommandAsync<AllChannelResponse[]>(new RPCRequest("allchannels", new object[] { })).ConfigureAwait(false);
+        }
+
+        public string[] Channels()
+        {
+            return ChannelsAsync().GetAwaiter().GetResult();
+        }
+
+        public async Task<string[]> ChannelsAsync()
+        {
+            return await SendCommandAsync<string[]>(new RPCRequest("channels", new object[] { })).ConfigureAwait(false);
+        }
+
+        public void Close(string channelId)
+        {
+            CloseAsync(channelId).GetAwaiter().GetResult();
+        }
+
+        public async Task CloseAsync(string channelId)
+        {
+            if (channelId == null)
+                throw new ArgumentNullException(nameof(channelId));
+            try
+            {
+                await SendCommandAsync(new RPCRequest("close", new object[] { channelId })).ConfigureAwait(false);
+            }
+            catch (RPCException ex) when (ex.Message == "closing already in progress")
+            {
+                
+            }
+        }
+
+        public ChannelResponse Channel(string channelId)
+        {
+            return ChannelAsync(channelId).GetAwaiter().GetResult();
+        }
+
+        public async Task<ChannelResponse> ChannelAsync(string channelId)
+        {
+            if (channelId == null)
+                throw new ArgumentNullException(nameof(channelId));
+            return await SendCommandAsync<ChannelResponse>(new RPCRequest("channel", new object[] { channelId })).ConfigureAwait(false);
+        }
+
+        public string[] AllNodes()
+        {
+            return AllNodesAsync().GetAwaiter().GetResult();
+        }
+
+        public async Task<string[]> AllNodesAsync()
+        {
+            return await SendCommandAsync<string[]>(new RPCRequest("allnodes", new object[] { })).ConfigureAwait(false);
+        }
+
+        public Uri Address { get; private set; }
+
+        private HttpWebRequest CreateWebRequest()
+        {
+            var webRequest = (HttpWebRequest)WebRequest.Create(Address.AbsoluteUri);
+            webRequest.ContentType = "application/json";
+            webRequest.Method = "POST";
+            return webRequest;
+        }
+
+
+        private async Task<Stream> ToMemoryStreamAsync(Stream stream)
+        {
+            MemoryStream ms = new MemoryStream();
+            await stream.CopyToAsync(ms).ConfigureAwait(false);
+            ms.Position = 0;
+            return ms;
+        }
+
+        public string Open(NodeInfo node, Money fundingSatoshi, LightMoney pushAmount = null)
+        {
+            return OpenAsync(node, fundingSatoshi, pushAmount).GetAwaiter().GetResult();
+        }
+
+        public string Connect(NodeInfo node)
+        {
+            return ConnectAsync(node).GetAwaiter().GetResult();
+        }
+
+        public async Task<string> ConnectAsync(NodeInfo node)
+        {
+            if (node == null)
+                throw new ArgumentNullException(nameof(node));
+            return (await SendCommandAsync(new RPCRequest("connect", new object[] { node.NodeId, node.Host, node.Port })).ConfigureAwait(false)).ResultString;
+        }
+
+        public string Receive(LightMoney amount, string description = null)
+        {
+            return ReceiveAsync(amount, description).GetAwaiter().GetResult();
+        }
+
+        public async Task<string> ReceiveAsync(LightMoney amount, string description = null)
+        {
+            if (amount == null)
+                throw new ArgumentNullException(nameof(amount));
+            List<object> args = new List<object>();
+            args.Add(amount.MilliSatoshi);
+            if(description != null)
+            {
+                args.Add(description);
+            }
+            return (await SendCommandAsync(new RPCRequest("receive", args.ToArray())).ConfigureAwait(false)).ResultString;
+        }
+
+        public async Task<string> OpenAsync(NodeInfo node, Money fundingSatoshi, LightMoney pushAmount = null)
+        {
+            if (fundingSatoshi == null)
+                throw new ArgumentNullException(nameof(fundingSatoshi));
+            if (node == null)
+                throw new ArgumentNullException(nameof(node));
+            pushAmount = pushAmount ?? LightMoney.Zero;
+
+            var result = await SendCommandAsync(new RPCRequest("open", new object[] { node.NodeId, node.Host, node.Port, fundingSatoshi.Satoshi, pushAmount.MilliSatoshi }));
+
+            return result.ResultString;
+        }
+
+
+    }
+}

BTCPayServer/Eclair/GetInfoResponse.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Eclair
+{
+    public class GetInfoResponse
+    {
+        public string NodeId { get; set; }
+        public string Alias { get; set; }
+        public int Port { get; set; }
+        public uint256 ChainHash { get; set; }
+        public int BlockHeight { get; set; }
+    }
+}

BTCPayServer/Eclair/LightMoney.cs

@@ -0,0 +1,569 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Eclair
+{
+    public enum LightMoneyUnit : ulong
+    {
+        BTC = 100000000000,
+        MilliBTC = 100000000,
+        Bit = 100000,
+        Satoshi = 1000,
+        MilliSatoshi = 1
+    }
+
+    public class LightMoney : IComparable, IComparable<LightMoney>, IEquatable<LightMoney>
+    {
+
+
+        // for decimal.TryParse. None of the NumberStyles' composed values is useful for bitcoin style
+        private const NumberStyles BitcoinStyle =
+                          NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite
+                        | NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint;
+
+
+        /// <summary>
+        /// Parse a bitcoin amount (Culture Invariant)
+        /// </summary>
+        /// <param name="bitcoin"></param>
+        /// <param name="nRet"></param>
+        /// <returns></returns>
+        public static bool TryParse(string bitcoin, out LightMoney nRet)
+        {
+            nRet = null;
+
+            decimal value;
+            if (!decimal.TryParse(bitcoin, BitcoinStyle, CultureInfo.InvariantCulture, out value))
+            {
+                return false;
+            }
+
+            try
+            {
+                nRet = new LightMoney(value, LightMoneyUnit.BTC);
+                return true;
+            }
+            catch (OverflowException)
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Parse a bitcoin amount (Culture Invariant)
+        /// </summary>
+        /// <param name="bitcoin"></param>
+        /// <returns></returns>
+        public static LightMoney Parse(string bitcoin)
+        {
+            LightMoney result;
+            if (TryParse(bitcoin, out result))
+            {
+                return result;
+            }
+            throw new FormatException("Impossible to parse the string in a bitcoin amount");
+        }
+
+        long _MilliSatoshis;
+        public long MilliSatoshi
+        {
+            get
+            {
+                return _MilliSatoshis;
+            }
+            // used as a central point where long.MinValue checking can be enforced 
+            private set
+            {
+                CheckLongMinValue(value);
+                _MilliSatoshis = value;
+            }
+        }
+
+        /// <summary>
+        /// Get absolute value of the instance
+        /// </summary>
+        /// <returns></returns>
+        public LightMoney Abs()
+        {
+            var a = this;
+            if (a < LightMoney.Zero)
+                a = -a;
+            return a;
+        }
+
+        public LightMoney(int satoshis)
+        {
+            MilliSatoshi = satoshis;
+        }
+
+        public LightMoney(uint satoshis)
+        {
+            MilliSatoshi = satoshis;
+        }
+
+        public LightMoney(long satoshis)
+        {
+            MilliSatoshi = satoshis;
+        }
+
+        public LightMoney(ulong satoshis)
+        {
+            // overflow check. 
+            // ulong.MaxValue is greater than long.MaxValue
+            checked
+            {
+                MilliSatoshi = (long)satoshis;
+            }
+        }
+
+        public LightMoney(decimal amount, LightMoneyUnit unit)
+        {
+            // sanity check. Only valid units are allowed
+            CheckMoneyUnit(unit, "unit");
+            checked
+            {
+                var satoshi = amount * (long)unit;
+                MilliSatoshi = (long)satoshi;
+            }
+        }
+
+
+        /// <summary>
+        /// Split the Money in parts without loss
+        /// </summary>
+        /// <param name="parts">The number of parts (must be more than 0)</param>
+        /// <returns>The splitted money</returns>
+        public IEnumerable<LightMoney> Split(int parts)
+        {
+            if (parts <= 0)
+                throw new ArgumentOutOfRangeException("Parts should be more than 0", "parts");
+            long remain;
+            long result = DivRem(_MilliSatoshis, parts, out remain);
+
+            for (int i = 0; i < parts; i++)
+            {
+                yield return LightMoney.Satoshis(result + (remain > 0 ? 1 : 0));
+                remain--;
+            }
+        }
+
+        private static long DivRem(long a, long b, out long result)
+        {
+            result = a % b;
+            return a / b;
+        }
+
+        public static LightMoney FromUnit(decimal amount, LightMoneyUnit unit)
+        {
+            return new LightMoney(amount, unit);
+        }
+
+        /// <summary>
+        /// Convert Money to decimal (same as ToDecimal)
+        /// </summary>
+        /// <param name="unit"></param>
+        /// <returns></returns>
+        public decimal ToUnit(LightMoneyUnit unit)
+        {
+            CheckMoneyUnit(unit, "unit");
+            // overflow safe because (long / int) always fit in decimal 
+            // decimal operations are checked by default
+            return (decimal)MilliSatoshi / (int)unit;
+        }
+        /// <summary>
+        /// Convert Money to decimal (same as ToUnit)
+        /// </summary>
+        /// <param name="unit"></param>
+        /// <returns></returns>
+        public decimal ToDecimal(LightMoneyUnit unit)
+        {
+            return ToUnit(unit);
+        }
+
+        public static LightMoney Coins(decimal coins)
+        {
+            // overflow safe.
+            // decimal operations are checked by default
+            return new LightMoney(coins * (ulong)LightMoneyUnit.BTC, LightMoneyUnit.MilliBTC);
+        }
+
+        public static LightMoney Bits(decimal bits)
+        {
+            // overflow safe.
+            // decimal operations are checked by default
+            return new LightMoney(bits * (ulong)LightMoneyUnit.Bit, LightMoneyUnit.MilliBTC);
+        }
+
+        public static LightMoney Cents(decimal cents)
+        {
+            // overflow safe.
+            // decimal operations are checked by default
+            return new LightMoney(cents * (ulong)LightMoneyUnit.Bit, LightMoneyUnit.MilliBTC);
+        }
+
+        public static LightMoney Satoshis(decimal sats)
+        {
+            return new LightMoney(sats * (ulong)LightMoneyUnit.Satoshi, LightMoneyUnit.MilliBTC);
+        }
+
+        public static LightMoney Satoshis(ulong sats)
+        {
+            return new LightMoney(sats);
+        }
+
+        public static LightMoney Satoshis(long sats)
+        {
+            return new LightMoney(sats);
+        }
+
+        public static LightMoney MilliSatoshis(long msats)
+        {
+            return new LightMoney(msats);
+        }
+
+        public static LightMoney MilliSatoshis(ulong msats)
+        {
+            return new LightMoney(msats);
+        }
+
+        #region IEquatable<Money> Members
+
+        public bool Equals(LightMoney other)
+        {
+            if (other == null)
+                return false;
+            return _MilliSatoshis.Equals(other._MilliSatoshis);
+        }
+
+        public int CompareTo(LightMoney other)
+        {
+            if (other == null)
+                return 1;
+            return _MilliSatoshis.CompareTo(other._MilliSatoshis);
+        }
+
+        #endregion
+
+        #region IComparable Members
+
+        public int CompareTo(object obj)
+        {
+            if (obj == null)
+                return 1;
+            LightMoney m = obj as LightMoney;
+            if (m != null)
+                return _MilliSatoshis.CompareTo(m._MilliSatoshis);
+#if !(PORTABLE || NETCORE)
+            return _MilliSatoshis.CompareTo(obj);
+#else
+			return _Satoshis.CompareTo((long)obj);
+#endif
+        }
+
+        #endregion
+
+        public static LightMoney operator -(LightMoney left, LightMoney right)
+        {
+            if (left == null)
+                throw new ArgumentNullException("left");
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return new LightMoney(checked(left._MilliSatoshis - right._MilliSatoshis));
+        }
+        public static LightMoney operator -(LightMoney left)
+        {
+            if (left == null)
+                throw new ArgumentNullException("left");
+            return new LightMoney(checked(-left._MilliSatoshis));
+        }
+        public static LightMoney operator +(LightMoney left, LightMoney right)
+        {
+            if (left == null)
+                throw new ArgumentNullException("left");
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return new LightMoney(checked(left._MilliSatoshis + right._MilliSatoshis));
+        }
+        public static LightMoney operator *(int left, LightMoney right)
+        {
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return LightMoney.Satoshis(checked(left * right._MilliSatoshis));
+        }
+
+        public static LightMoney operator *(LightMoney right, int left)
+        {
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return LightMoney.Satoshis(checked(right._MilliSatoshis * left));
+        }
+        public static LightMoney operator *(long left, LightMoney right)
+        {
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return LightMoney.Satoshis(checked(left * right._MilliSatoshis));
+        }
+        public static LightMoney operator *(LightMoney right, long left)
+        {
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return LightMoney.Satoshis(checked(left * right._MilliSatoshis));
+        }
+
+        public static LightMoney operator /(LightMoney left, long right)
+        {
+            if (left == null)
+                throw new ArgumentNullException("left");
+            return new LightMoney(checked(left._MilliSatoshis / right));
+        }
+
+        public static bool operator <(LightMoney left, LightMoney right)
+        {
+            if (left == null)
+                throw new ArgumentNullException("left");
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return left._MilliSatoshis < right._MilliSatoshis;
+        }
+        public static bool operator >(LightMoney left, LightMoney right)
+        {
+            if (left == null)
+                throw new ArgumentNullException("left");
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return left._MilliSatoshis > right._MilliSatoshis;
+        }
+        public static bool operator <=(LightMoney left, LightMoney right)
+        {
+            if (left == null)
+                throw new ArgumentNullException("left");
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return left._MilliSatoshis <= right._MilliSatoshis;
+        }
+        public static bool operator >=(LightMoney left, LightMoney right)
+        {
+            if (left == null)
+                throw new ArgumentNullException("left");
+            if (right == null)
+                throw new ArgumentNullException("right");
+            return left._MilliSatoshis >= right._MilliSatoshis;
+        }
+
+        public static implicit operator LightMoney(long value)
+        {
+            return new LightMoney(value);
+        }
+        public static implicit operator LightMoney(int value)
+        {
+            return new LightMoney(value);
+        }
+
+        public static implicit operator LightMoney(uint value)
+        {
+            return new LightMoney(value);
+        }
+
+        public static implicit operator LightMoney(ulong value)
+        {
+            return new LightMoney(checked((long)value));
+        }
+
+        public static implicit operator long(LightMoney value)
+        {
+            return value.MilliSatoshi;
+        }
+
+        public static implicit operator ulong(LightMoney value)
+        {
+            return checked((ulong)value.MilliSatoshi);
+        }
+
+        public static implicit operator LightMoney(string value)
+        {
+            return LightMoney.Parse(value);
+        }
+
+        public override bool Equals(object obj)
+        {
+            LightMoney item = obj as LightMoney;
+            if (item == null)
+                return false;
+            return _MilliSatoshis.Equals(item._MilliSatoshis);
+        }
+        public static bool operator ==(LightMoney a, LightMoney b)
+        {
+            if (Object.ReferenceEquals(a, b))
+                return true;
+            if (((object)a == null) || ((object)b == null))
+                return false;
+            return a._MilliSatoshis == b._MilliSatoshis;
+        }
+
+        public static bool operator !=(LightMoney a, LightMoney b)
+        {
+            return !(a == b);
+        }
+
+        public override int GetHashCode()
+        {
+            return _MilliSatoshis.GetHashCode();
+        }
+
+
+        /// <summary>
+        /// Returns a culture invariant string representation of Bitcoin amount
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            return ToString(false, false);
+        }
+
+        /// <summary>
+        /// Returns a culture invariant string representation of Bitcoin amount
+        /// </summary>
+        /// <param name="fplus">True if show + for a positive amount</param>
+        /// <param name="trimExcessZero">True if trim excess zeroes</param>
+        /// <returns></returns>
+        public string ToString(bool fplus, bool trimExcessZero = true)
+        {
+            var fmt = string.Format("{{0:{0}{1}B}}",
+                                    (fplus ? "+" : null),
+                                    (trimExcessZero ? "2" : "11"));
+            return string.Format(BitcoinFormatter.Formatter, fmt, _MilliSatoshis);
+        }
+
+
+        static LightMoney _Zero = new LightMoney(0);
+        public static LightMoney Zero
+        {
+            get
+            {
+                return _Zero;
+            }
+        }
+
+        internal class BitcoinFormatter : IFormatProvider, ICustomFormatter
+        {
+            public static readonly BitcoinFormatter Formatter = new BitcoinFormatter();
+
+            public object GetFormat(Type formatType)
+            {
+                return formatType == typeof(ICustomFormatter) ? this : null;
+            }
+
+            public string Format(string format, object arg, IFormatProvider formatProvider)
+            {
+                if (!this.Equals(formatProvider))
+                {
+                    return null;
+                }
+                var i = 0;
+                var plus = format[i] == '+';
+                if (plus)
+                    i++;
+                int decPos = 0;
+                if (int.TryParse(format.Substring(i, 1), out decPos))
+                {
+                    i++;
+                }
+                var unit = format[i];
+                var unitToUseInCalc = LightMoneyUnit.BTC;
+                switch (unit)
+                {
+                    case 'B':
+                        unitToUseInCalc = LightMoneyUnit.BTC;
+                        break;
+                }
+                var val = Convert.ToDecimal(arg) / (long)unitToUseInCalc;
+                var zeros = new string('0', decPos);
+                var rest = new string('#', 11 - decPos);
+                var fmt = plus && val > 0 ? "+" : string.Empty;
+
+                fmt += "{0:0" + (decPos > 0 ? "." + zeros + rest : string.Empty) + "}";
+                return string.Format(CultureInfo.InvariantCulture, fmt, val);
+            }
+        }
+
+        /// <summary>
+        /// Tell if amount is almost equal to this instance
+        /// </summary>
+        /// <param name="amount"></param>
+        /// <param name="dust">more or less amount</param>
+        /// <returns>true if equals, else false</returns>
+        public bool Almost(LightMoney amount, LightMoney dust)
+        {
+            if (amount == null)
+                throw new ArgumentNullException("amount");
+            if (dust == null)
+                throw new ArgumentNullException("dust");
+            return (amount - this).Abs() <= dust;
+        }
+
+        /// <summary>
+        /// Tell if amount is almost equal to this instance
+        /// </summary>
+        /// <param name="amount"></param>
+        /// <param name="margin">error margin (between 0 and 1)</param>
+        /// <returns>true if equals, else false</returns>
+        public bool Almost(LightMoney amount, decimal margin)
+        {
+            if (amount == null)
+                throw new ArgumentNullException("amount");
+            if (margin < 0.0m || margin > 1.0m)
+                throw new ArgumentOutOfRangeException("margin", "margin should be between 0 and 1");
+            var dust = LightMoney.Satoshis((decimal)this.MilliSatoshi * margin);
+            return Almost(amount, dust);
+        }
+
+        public static LightMoney Min(LightMoney a, LightMoney b)
+        {
+            if (a == null)
+                throw new ArgumentNullException("a");
+            if (b == null)
+                throw new ArgumentNullException("b");
+            if (a <= b)
+                return a;
+            return b;
+        }
+
+        public static LightMoney Max(LightMoney a, LightMoney b)
+        {
+            if (a == null)
+                throw new ArgumentNullException("a");
+            if (b == null)
+                throw new ArgumentNullException("b");
+            if (a >= b)
+                return a;
+            return b;
+        }
+
+        private static void CheckLongMinValue(long value)
+        {
+            if (value == long.MinValue)
+                throw new OverflowException("satoshis amount should be greater than long.MinValue");
+        }
+
+        private static void CheckMoneyUnit(LightMoneyUnit value, string paramName)
+        {
+            var typeOfMoneyUnit = typeof(LightMoneyUnit);
+            if (!Enum.IsDefined(typeOfMoneyUnit, value))
+            {
+                throw new ArgumentException("Invalid value for MoneyUnit", paramName);
+            }
+        }
+
+        #region IComparable Members
+
+        int IComparable.CompareTo(object obj)
+        {
+            return this.CompareTo(obj);
+        }
+
+        #endregion
+    }
+}

BTCPayServer/Eclair/NodeInfo.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Eclair
+{
+    public class NodeInfo
+    {
+        public NodeInfo(string nodeId, string host, int port)
+        {
+            if (host == null)
+                throw new ArgumentNullException(nameof(host));
+            if (nodeId == null)
+                throw new ArgumentNullException(nameof(nodeId));
+            Port = port;
+            Host = host;
+            NodeId = nodeId;
+        }
+        public string NodeId { get; private set; }
+        public string Host { get; private set; }
+        public int Port { get; private set; }
+    }
+}

BTCPayServer/EventAggregator.cs

@@ -0,0 +1,130 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+
+namespace BTCPayServer
+{
+    public interface IEventAggregatorSubscription : IDisposable
+    {
+        void Unsubscribe();
+        void Resubscribe();
+    }
+    public class EventAggregator : IDisposable
+    {
+        class Subscription : IEventAggregatorSubscription
+        {
+            private EventAggregator aggregator;
+            Type t;
+            Action<object> act;
+            public Subscription(EventAggregator aggregator, Type t)
+            {
+                this.aggregator = aggregator;
+                this.t = t;
+            }
+
+            public Action<Object> Act { get; set; }
+
+            public void Dispose()
+            {
+                lock (this.aggregator._Subscriptions)
+                {
+                    if (this.aggregator._Subscriptions.TryGetValue(t, out Dictionary<Subscription, Action<object>> actions))
+                    {
+                        if (actions.Remove(this))
+                        {
+                            if (actions.Count == 0)
+                                this.aggregator._Subscriptions.Remove(t);
+                        }
+                    }
+                }
+            }
+
+            public void Resubscribe()
+            {
+                aggregator.Subscribe(t, this);
+            }
+
+            public void Unsubscribe()
+            {
+                Dispose();
+            }
+        }
+
+        public void Publish<T>(T evt) where T : class
+        {
+            if (evt == null)
+                throw new ArgumentNullException(nameof(evt));
+            List<Action<object>> actionList = new List<Action<object>>();
+            lock (_Subscriptions)
+            {
+                if (_Subscriptions.TryGetValue(typeof(T), out Dictionary<Subscription, Action<object>> actions))
+                {
+                    actionList = actions.Values.ToList();
+                }
+            }
+
+            Logs.Events.LogInformation($"New event: {evt.ToString()}");
+            foreach (var sub in actionList)
+            {
+                try
+                {
+                    sub(evt);
+                }
+                catch (Exception ex)
+                {
+                    Logs.Events.LogError(ex, $"Error while calling event handler");
+                }
+            }
+        }
+
+        public IEventAggregatorSubscription Subscribe<T>(Action<IEventAggregatorSubscription, T> subscription)
+        {
+            var eventType = typeof(T);
+            var s = new Subscription(this, eventType);
+            s.Act = (o) => subscription(s, (T)o);
+            return Subscribe(eventType, s);
+        }
+
+        private IEventAggregatorSubscription Subscribe(Type eventType, Subscription subscription)
+        {
+            lock (_Subscriptions)
+            {
+                if (!_Subscriptions.TryGetValue(eventType, out Dictionary<Subscription, Action<object>> actions))
+                {
+                    actions = new Dictionary<Subscription, Action<object>>();
+                    _Subscriptions.Add(eventType, actions);
+                }
+                actions.Add(subscription, subscription.Act);
+            }
+            return subscription;
+        }
+
+        Dictionary<Type, Dictionary<Subscription, Action<object>>> _Subscriptions = new Dictionary<Type, Dictionary<Subscription, Action<object>>>();
+
+        public IEventAggregatorSubscription Subscribe<T, TReturn>(Func<T, TReturn> subscription)
+        {
+            return Subscribe(new Action<T>((t) => subscription(t)));
+        }
+
+        public IEventAggregatorSubscription Subscribe<T, TReturn>(Func<IEventAggregatorSubscription, T, TReturn> subscription)
+        {
+            return Subscribe(new Action<IEventAggregatorSubscription, T>((sub, t) => subscription(sub, t)));
+        }
+
+        public IEventAggregatorSubscription Subscribe<T>(Action<T> subscription)
+        {
+            return Subscribe(new Action<IEventAggregatorSubscription, T>((sub, t) => subscription(t)));
+        }
+
+        public void Dispose()
+        {
+            lock (_Subscriptions)
+            {
+                _Subscriptions.Clear();
+            }
+        }
+    }
+}

BTCPayServer/Events/InvoiceDataChangedEvent.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceDataChangedEvent
+    {
+        public string InvoiceId { get; set; }
+
+        public override string ToString()
+        {
+            return $"Invoice {InvoiceId} data changed";
+        }
+    }
+}

BTCPayServer/Events/InvoicePaymentEvent.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+
+namespace BTCPayServer.Events
+{
+    public class InvoicePaymentEvent
+    {
+        
+        public InvoicePaymentEvent(string invoiceId)
+        {
+            InvoiceId = invoiceId;
+        }
+
+        public string InvoiceId { get; set; }
+
+        public override string ToString()
+        {
+            return $"Invoice {InvoiceId} received a payment";
+        }
+    }
+}

BTCPayServer/Events/InvoiceStatusChangedEvent.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceStatusChangedEvent
+    {
+        public InvoiceStatusChangedEvent()
+        {
+
+        }
+        public InvoiceStatusChangedEvent(InvoiceEntity invoice, string newState)
+        {
+            OldState = invoice.Status;
+            InvoiceId = invoice.Id;
+            NewState = newState;
+        }
+        public string InvoiceId { get; set; }
+        public string OldState { get; set; }
+        public string NewState { get; set; }
+
+        public override string ToString()
+        {
+            return $"Invoice {InvoiceId} changed status: {OldState} => {NewState}";
+        }
+    }
+}

BTCPayServer/Events/NBXplorerStateChangedEvent.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class NBXplorerStateChangedEvent
+    {
+        public NBXplorerStateChangedEvent(NBXplorerState old, NBXplorerState newState)
+        {
+            NewState = newState;
+            OldState = old;
+        }
+
+        public NBXplorerState NewState { get; set; }
+        public NBXplorerState OldState { get; set; }
+
+        public override string ToString()
+        {
+            return $"NBXplorer: {OldState} => {NewState}";
+        }
+    }
+}

BTCPayServer/Events/NewBlockEvent.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class NewBlockEvent
+    {
+        public override string ToString()
+        {
+            return "New block";
+        }
+    }
+}

BTCPayServer/Events/TxOutReceivedEvent.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+
+namespace BTCPayServer.Events
+{
+    public class TxOutReceivedEvent
+    {
+        public Script ScriptPubKey { get; set; }
+        public BitcoinAddress Address { get; set; }
+
+        public override string ToString()
+        {
+            String address = Address?.ToString() ?? ScriptPubKey.ToHex();
+            return $"{address} received a transaction";
+        }
+    }
+}

BTCPayServer/Extensions.cs

@@ -71,10 +71,10 @@ namespace BTCPayServer
             return res;
         }
 
-        public static HtmlString ToSrvModel(this object o)
+        public static HtmlString ToJSVariableModel(this object o, string variableName)
         {
             var encodedJson = JavaScriptEncoder.Default.Encode(o.ToJson());
-            return new HtmlString("var srvModel = JSON.parse('" + encodedJson + "');");
+            return new HtmlString($"var {variableName} = JSON.parse('" + encodedJson + "');");
         }
 
 

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -1,4 +1,5 @@
 using BTCPayServer.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.AspNetCore.Hosting;
 using System;
 using System.Collections.Generic;
@@ -34,6 +35,7 @@ using System.Threading;
 using BTCPayServer.Services.Wallets;
 using BTCPayServer.Authentication;
 using Microsoft.Extensions.Caching.Memory;
+using BTCPayServer.Logging;
 
 namespace BTCPayServer.Hosting
 {
@@ -83,19 +85,6 @@ namespace BTCPayServer.Hosting
                 }
             }
         }
-        class BTCPayServerConfigureOptions : IConfigureOptions<MvcOptions>
-        {
-            BTCPayServerOptions _Options;
-            public BTCPayServerConfigureOptions(BTCPayServerOptions options)
-            {
-                _Options = options;
-            }
-            public void Configure(MvcOptions options)
-            {
-                if (_Options.RequireHttps)
-                    options.Filters.Add(new RequireHttpsAttribute());
-            }
-        }
         public static IServiceCollection AddBTCPayServer(this IServiceCollection services)
         {
             services.AddDbContext<ApplicationDbContext>((provider, o) =>
@@ -106,18 +95,36 @@ namespace BTCPayServer.Hosting
             services.TryAddSingleton<SettingsRepository>();
             services.TryAddSingleton<InvoicePaymentNotification>();
             services.TryAddSingleton<BTCPayServerOptions>(o => o.GetRequiredService<IOptions<BTCPayServerOptions>>().Value);
-            services.TryAddSingleton<IConfigureOptions<MvcOptions>, BTCPayServerConfigureOptions>();
-            services.TryAddSingleton(o =>
+            services.TryAddSingleton<InvoiceRepository>(o =>
             {
-                var runtime = new BTCPayServerRuntime();
-                runtime.Configure(o.GetRequiredService<BTCPayServerOptions>());
-                return runtime;
+                var opts = o.GetRequiredService<BTCPayServerOptions>();
+                var dbContext = o.GetRequiredService<ApplicationDbContextFactory>();
+                var dbpath = Path.Combine(opts.DataDir, "InvoiceDB");
+                if (!Directory.Exists(dbpath))
+                    Directory.CreateDirectory(dbpath);
+                return new InvoiceRepository(dbContext, dbpath, opts.Network);
             });
             services.AddSingleton<BTCPayServerEnvironment>();
             services.TryAddSingleton<TokenRepository>();
-            services.TryAddSingleton(o => o.GetRequiredService<BTCPayServerRuntime>().InvoiceRepository);
+            services.TryAddSingleton<EventAggregator>();
             services.TryAddSingleton<Network>(o => o.GetRequiredService<BTCPayServerOptions>().Network);
-            services.TryAddSingleton<ApplicationDbContextFactory>(o => o.GetRequiredService<BTCPayServerRuntime>().DBFactory);
+            services.TryAddSingleton<ApplicationDbContextFactory>(o => 
+            {
+                var opts = o.GetRequiredService<BTCPayServerOptions>();
+                ApplicationDbContextFactory dbContext = null;
+                if (opts.PostgresConnectionString == null)
+                {
+                    var connStr = "Data Source=" + Path.Combine(opts.DataDir, "sqllite.db");
+                    Logs.Configuration.LogInformation($"SQLite DB used ({connStr})");
+                    dbContext = new ApplicationDbContextFactory(DatabaseType.Sqlite, connStr);
+                }
+                else
+                {
+                    Logs.Configuration.LogInformation($"Postgres DB used ({opts.PostgresConnectionString})");
+                    dbContext = new ApplicationDbContextFactory(DatabaseType.Postgres, opts.PostgresConnectionString);
+                }
+                return dbContext;
+            });
             services.TryAddSingleton<StoreRepository>();
             services.TryAddSingleton<BTCPayWallet>();
             services.TryAddSingleton<CurrencyNameTable>();
@@ -127,10 +134,16 @@ namespace BTCPayServer.Hosting
                 BlockTarget = 20,
                 ExplorerClient = o.GetRequiredService<ExplorerClient>()
             });
+
+            services.TryAddSingleton<NBXplorerWaiterAccessor>();
+            services.AddSingleton<IHostedService, NBXplorerWaiter>();
             services.TryAddSingleton<ExplorerClient>(o =>
             {
-                var runtime = o.GetRequiredService<BTCPayServerRuntime>();
-                return runtime.Explorer;
+                var opts = o.GetRequiredService<BTCPayServerOptions>();
+                var explorer = new ExplorerClient(opts.Network, opts.Explorer);
+                if (!explorer.SetCookieAuth(opts.CookieFile))
+                    explorer.SetNoAuth();
+                return explorer;
             });
             services.TryAddSingleton<Bitpay>(o =>
             {
@@ -141,11 +154,16 @@ namespace BTCPayServer.Hosting
             });
             services.TryAddSingleton<IRateProvider>(o =>
             {
-                return new CachedRateProvider(new CoinAverageRateProvider(), o.GetRequiredService<IMemoryCache>()) { CacheSpan = TimeSpan.FromMinutes(1.0) };
+                var coinaverage = new CoinAverageRateProvider();
+                var bitpay = new BitpayRateProvider(new Bitpay(new Key(), new Uri("https://bitpay.com/")));
+                return new CachedRateProvider(new FallbackRateProvider(new IRateProvider[] { coinaverage, bitpay }), o.GetRequiredService<IMemoryCache>()) { CacheSpan = TimeSpan.FromMinutes(1.0) };
             });
-            services.TryAddSingleton<InvoiceWatcher>();
-            services.TryAddSingleton<InvoiceNotificationManager>();
-            services.TryAddSingleton<IHostedService>(o => o.GetRequiredService<InvoiceWatcher>());
+            
+            services.AddSingleton<IHostedService, InvoiceNotificationManager>();
+
+            services.TryAddSingleton<InvoiceWatcherAccessor>();
+            services.AddSingleton<IHostedService, InvoiceWatcher>();
+            services.TryAddSingleton<Initializer>();
             services.TryAddScoped<IHttpContextAccessor, HttpContextAccessor>();
             services.TryAddSingleton<IAuthorizationHandler, OwnStoreHandler>();
             services.AddTransient<AccessTokenController>();
@@ -172,12 +190,6 @@ namespace BTCPayServer.Hosting
 
         public static IApplicationBuilder UsePayServer(this IApplicationBuilder app)
         {
-            if (app.ApplicationServices.GetRequiredService<BTCPayServerOptions>().RequireHttps)
-            {
-                var options = new RewriteOptions().AddRedirectToHttps();
-                app.UseRewriter(options);
-            }
-
             using (var scope = app.ApplicationServices.GetService<IServiceScopeFactory>().CreateScope())
             {
                 //Wait the DB is ready
@@ -186,6 +198,11 @@ namespace BTCPayServer.Hosting
                     scope.ServiceProvider.GetRequiredService<ApplicationDbContext>().Database.Migrate();
                 });
             }
+
+
+
+            var initialize = app.ApplicationServices.GetService<Initializer>();
+            initialize.Init();
             app.UseMiddleware<BTCPayMiddleware>();
             return app;
         }

BTCPayServer/Hosting/BTCpayMiddleware.cs

@@ -29,40 +29,21 @@ namespace BTCPayServer.Hosting
     {
         TokenRepository _TokenRepository;
         RequestDelegate _Next;
-        CallbackController _CallbackController;
         BTCPayServerOptions _Options;
+
         public BTCPayMiddleware(RequestDelegate next,
             TokenRepository tokenRepo,
-            BTCPayServerOptions options,
-            CallbackController callbackController)
+            BTCPayServerOptions options)
         {
             _TokenRepository = tokenRepo ?? throw new ArgumentNullException(nameof(tokenRepo));
             _Next = next ?? throw new ArgumentNullException(nameof(next));
-            _CallbackController = callbackController;
             _Options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
 
-        bool _Registered;
         public async Task Invoke(HttpContext httpContext)
         {
-            if (!_Registered)
-            {
-                var callback = await _CallbackController.RegisterCallbackBlockUriAsync(httpContext.Request);
-                Logs.PayServer.LogInformation($"Registering block callback to " + callback);
-                _Registered = true;
-            }
-
-            // Make sure that code executing after this point think that the external url has been hit.
-            if(_Options.ExternalUrl != null)
-            {
-                httpContext.Request.Scheme = _Options.ExternalUrl.Scheme;
-                if(_Options.ExternalUrl.IsDefaultPort)
-                    httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host);
-                else
-                    httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, _Options.ExternalUrl.Port);
-            }
-
+            RewriteHostIfNeeded(httpContext);
             httpContext.Request.Headers.TryGetValue("x-signature", out StringValues values);
             var sig = values.FirstOrDefault();
             httpContext.Request.Headers.TryGetValue("x-identity", out values);
@@ -116,6 +97,53 @@ namespace BTCPayServer.Hosting
             }
         }
 
+        private void RewriteHostIfNeeded(HttpContext httpContext)
+        {
+            // Make sure that code executing after this point think that the external url has been hit.
+            if (_Options.ExternalUrl != null)
+            {
+                httpContext.Request.Scheme = _Options.ExternalUrl.Scheme;
+                if (_Options.ExternalUrl.IsDefaultPort)
+                    httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host);
+                else
+                    httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, _Options.ExternalUrl.Port);
+            }
+            // NGINX pass X-Forwarded-Proto and X-Forwarded-Port, so let's use that to have better guess of the real domain
+            else
+            {
+                ushort? p = null;
+                if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Proto", out StringValues proto))
+                {
+                    var scheme = proto.SingleOrDefault();
+                    if (scheme != null)
+                    {
+                        httpContext.Request.Scheme = scheme;
+                        if (scheme == "http")
+                            p = 80;
+                        if (scheme == "https")
+                            p = 443;
+                    }
+                }
+                if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Port", out StringValues port))
+                {
+                    var portString = port.SingleOrDefault();
+                    if (portString != null && ushort.TryParse(portString, out ushort pp))
+                    {
+                        p = pp;
+                    }
+                }
+                if (p.HasValue)
+                {
+                    bool isDefault = httpContext.Request.Scheme == "http" && p.Value == 80;
+                    isDefault |= httpContext.Request.Scheme == "https" && p.Value == 443;
+                    if (isDefault)
+                        httpContext.Request.Host = new HostString(httpContext.Request.Host.Host);
+                    else
+                        httpContext.Request.Host = new HostString(httpContext.Request.Host.Host, p.Value);
+                }
+            }
+        }
+
         private static async Task HandleBitpayHttpException(HttpContext httpContext, BitpayHttpException ex)
         {
             httpContext.Response.StatusCode = ex.StatusCode;

BTCPayServer/Hosting/Startup.cs

@@ -144,6 +144,7 @@ namespace BTCPayServer.Hosting
             app.UseAuthentication();
             app.UseHangfireServer();
             app.UseHangfireDashboard("/hangfire", new DashboardOptions() { Authorization = new[] { new NeedRole(Roles.ServerAdmin) } });
+            app.UseWebSockets();
             app.UseMvc(routes =>
             {
                 routes.MapRoute(

BTCPayServer/Initializer.cs

@@ -0,0 +1,45 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Logging;
+using BTCPayServer.Events;
+
+namespace BTCPayServer
+{
+    public class Initializer
+    {
+        EventAggregator _Aggregator;
+        CallbackController _CallbackController;
+        public Initializer(EventAggregator aggregator, 
+            CallbackController callbackController
+            )
+        {
+            _Aggregator = aggregator;
+            _CallbackController = callbackController;
+        }
+        public void Init()
+        {
+            _Aggregator.Subscribe<NBXplorerStateChangedEvent>(async (s, evt) =>
+            {
+                if (evt.NewState == NBXplorerState.Ready)
+                {
+                    s.Unsubscribe();
+                    try
+                    {
+                        var callback = await _CallbackController.GetCallbackBlockUriAsync();
+                        await _CallbackController.RegisterCallbackBlockUriAsync(callback);
+                        Logs.PayServer.LogInformation($"Registering block callback to " + callback);
+                    }
+                    catch (Exception ex)
+                    {
+                        Logs.PayServer.LogError(ex, "Could not register block callback");
+                        s.Resubscribe();
+                    }
+                }
+            });
+        }
+    }
+}

BTCPayServer/Logging/Logs.cs

@@ -17,6 +17,7 @@ namespace BTCPayServer.Logging
         {
             Configuration = factory.CreateLogger("Configuration");
             PayServer = factory.CreateLogger("PayServer");
+            Events = factory.CreateLogger("PayServer");
         }
         public static ILogger Configuration
         {
@@ -26,6 +27,12 @@ namespace BTCPayServer.Logging
         {
             get; set;
         }
+
+        public static ILogger Events
+        {
+            get; set;
+        }
+
         public const int ColumnLength = 16;
     }
 

BTCPayServer/NBXplorerWaiter.cs

@@ -0,0 +1,175 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+using Microsoft.Extensions.Hosting;
+using NBXplorer;
+using NBXplorer.Models;
+using System.Collections.Concurrent;
+using BTCPayServer.Events;
+
+namespace BTCPayServer
+{
+    public class NBXplorerWaiterAccessor
+    {
+        public NBXplorerWaiter Instance { get; set; }
+    }
+    public enum NBXplorerState
+    {
+        NotConnected,
+        Synching,
+        Ready
+    }
+
+    public class NBXplorerWaiter : IHostedService
+    {
+        public NBXplorerWaiter(ExplorerClient client, EventAggregator aggregator, NBXplorerWaiterAccessor accessor)
+        {
+            _Client = client;
+            _Aggregator = aggregator;
+            accessor.Instance = this;
+        }
+
+        EventAggregator _Aggregator;
+        ExplorerClient _Client;
+        Timer _Timer;
+        ManualResetEventSlim _Idle = new ManualResetEventSlim(true);
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Timer = new Timer(Callback, null, 0, (int)TimeSpan.FromMinutes(1.0).TotalMilliseconds);
+            return Task.CompletedTask;
+        }
+
+        void Callback(object state)
+        {
+            if (!_Idle.IsSet)
+                return;
+            try
+            {
+                _Idle.Reset();
+                CheckStatus().GetAwaiter().GetResult();
+            }
+            catch (Exception ex)
+            {
+                Logs.PayServer.LogError(ex, "Error while checking NBXplorer state");
+            }
+            finally
+            {
+                _Idle.Set();
+            }
+        }
+
+        async Task CheckStatus()
+        {
+            while (await StepAsync())
+            {
+
+            }
+        }
+
+        private async Task<bool> StepAsync()
+        {
+            var oldState = State;
+
+            StatusResult status = null;
+            switch (State)
+            {
+                case NBXplorerState.NotConnected:
+                    status = await GetStatusWithTimeout();
+                    if (status != null)
+                    {
+                        if (status.IsFullySynched())
+                        {
+                            State = NBXplorerState.Ready;
+                        }
+                        else
+                        {
+                            State = NBXplorerState.Synching;
+                        }
+                    }
+                    break;
+                case NBXplorerState.Synching:
+                    status = await GetStatusWithTimeout();
+                    if (status == null)
+                    {
+                        State = NBXplorerState.NotConnected;
+                    }
+                    else if (status.IsFullySynched())
+                    {
+                        State = NBXplorerState.Ready;
+                    }
+                    break;
+                case NBXplorerState.Ready:
+                    status = await GetStatusWithTimeout();
+                    if (status == null)
+                    {
+                        State = NBXplorerState.NotConnected;
+                    }
+                    else if (!status.IsFullySynched())
+                    {
+                        State = NBXplorerState.Synching;
+                    }
+                    break;
+            }
+
+            LastStatus = status;
+            if (oldState != State)
+            {
+                if (State == NBXplorerState.Synching)
+                {
+                    SetInterval(TimeSpan.FromSeconds(10));
+                }
+                else
+                {
+                    SetInterval(TimeSpan.FromMinutes(1));
+                }
+                _Aggregator.Publish(new NBXplorerStateChangedEvent(oldState, State));
+            }
+            return oldState != State;
+        }
+
+        private void SetInterval(TimeSpan interval)
+        {
+            try
+            {
+                _Timer.Change(0, (int)interval.TotalMilliseconds);
+            }
+            catch { }
+        }
+
+        private async Task<StatusResult> GetStatusWithTimeout()
+        {
+            CancellationTokenSource cts = new CancellationTokenSource();
+            using (cts)
+            {
+                var cancellation = cts.Token;
+                while (!cancellation.IsCancellationRequested)
+                {
+                    try
+                    {
+                        var status = await _Client.GetStatusAsync(cancellation).ConfigureAwait(false);
+                        return status;
+                    }
+                    catch (OperationCanceledException) { }
+                    catch { }
+                }
+            }
+            return null;
+        }
+
+        public NBXplorerState State { get; private set; }
+
+        public StatusResult LastStatus { get; private set; }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            _Timer.Dispose();
+            _Timer = null;
+            _Idle.Wait();
+            return Task.CompletedTask;
+        }
+    }
+}

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -286,7 +286,7 @@ namespace BTCPayServer.Services.Invoices
                 CurrentTime = DateTimeOffset.UtcNow,
                 InvoiceTime = InvoiceTime,
                 ExpirationTime = ExpirationTime,
-                BTCPrice = Money.Coins((decimal)(1.0 / Rate)).ToString(),
+                BTCPrice = Money.Coins((decimal)(ProductInformation.Price / Rate)).ToString(),
                 Status = Status,
                 Url = ServerUrl.WithTrailingSlash() + "invoice?id=" + Id,
                 Currency = ProductInformation.Currency,

BTCPayServer/Services/Invoices/InvoiceNotificationManager.cs

@@ -15,10 +15,12 @@ using NBitpayClient;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json;
 using System.Collections.Concurrent;
+using Microsoft.Extensions.Hosting;
+using BTCPayServer.Events;
 
 namespace BTCPayServer.Services.Invoices
 {
-    public class InvoiceNotificationManager
+    public class InvoiceNotificationManager : IHostedService
     {
         public static HttpClient _Client = new HttpClient();
 
@@ -41,16 +43,32 @@ namespace BTCPayServer.Services.Invoices
         }
 
         IBackgroundJobClient _JobClient;
+        EventAggregator _EventAggregator;
+        InvoiceRepository _InvoiceRepository;
+
         public InvoiceNotificationManager(
             IBackgroundJobClient jobClient,
+            EventAggregator eventAggregator,
+            InvoiceRepository invoiceRepository,
             ILogger<InvoiceNotificationManager> logger)
         {
             Logger = logger as ILogger ?? NullLogger.Instance;
             _JobClient = jobClient;
+            _EventAggregator = eventAggregator;
+            _InvoiceRepository = invoiceRepository;
         }
 
-        public void Notify(InvoiceEntity invoice)
+        async Task Notify(InvoiceEntity invoice)
         {
+            CancellationTokenSource cts = new CancellationTokenSource(10000);
+            try
+            {
+                await SendNotification(invoice, cts.Token);
+                return;
+            }
+            catch // It fails, it is OK because we try with hangfire after
+            {
+            }
             var invoiceStr = NBitcoin.JsonConverters.Serializer.ToString(new ScheduledJob() { TryCount = 0, Invoice = invoice });
             if (!string.IsNullOrEmpty(invoice.NotificationURL))
                 _JobClient.Schedule(() => NotifyHttp(invoiceStr), TimeSpan.Zero);
@@ -70,31 +88,7 @@ namespace BTCPayServer.Services.Invoices
             CancellationTokenSource cts = new CancellationTokenSource(10000);
             try
             {
-                var request = new HttpRequestMessage();
-                request.Method = HttpMethod.Post;
-
-                var dto = job.Invoice.EntityToDTO();
-                InvoicePaymentNotification notification = new InvoicePaymentNotification()
-                {
-                    Id = dto.Id,
-                    Url = dto.Url,
-                    BTCDue = dto.BTCDue,
-                    BTCPaid = dto.BTCPaid,
-                    BTCPrice = dto.BTCPrice,
-                    Currency = dto.Currency,
-                    CurrentTime = dto.CurrentTime,
-                    ExceptionStatus = dto.ExceptionStatus,
-                    ExpirationTime = dto.ExpirationTime,
-                    InvoiceTime = dto.InvoiceTime,
-                    PosData = dto.PosData,
-                    Price = dto.Price,
-                    Rate = dto.Rate,
-                    Status = dto.Status,
-                    BuyerFields = job.Invoice.RefundMail == null ? null : new Newtonsoft.Json.Linq.JObject() { new JProperty("buyerEmail", job.Invoice.RefundMail) }
-                };
-                request.RequestUri = new Uri(job.Invoice.NotificationURL, UriKind.Absolute);
-                request.Content = new StringContent(JsonConvert.SerializeObject(notification), Encoding.UTF8, "application/json");
-                var response = await _Client.SendAsync(request, cts.Token);
+                HttpResponseMessage response = await SendNotification(job.Invoice, cts.Token);
                 reschedule = response.StatusCode != System.Net.HttpStatusCode.OK;
                 Logger.LogInformation("Job " + jobId + " returned " + response.StatusCode);
             }
@@ -116,11 +110,73 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
+        private static async Task<HttpResponseMessage> SendNotification(InvoiceEntity invoice, CancellationToken cancellation)
+        {
+            var request = new HttpRequestMessage();
+            request.Method = HttpMethod.Post;
+
+            var dto = invoice.EntityToDTO();
+            InvoicePaymentNotification notification = new InvoicePaymentNotification()
+            {
+                Id = dto.Id,
+                Url = dto.Url,
+                BTCDue = dto.BTCDue,
+                BTCPaid = dto.BTCPaid,
+                BTCPrice = dto.BTCPrice,
+                Currency = dto.Currency,
+                CurrentTime = dto.CurrentTime,
+                ExceptionStatus = dto.ExceptionStatus,
+                ExpirationTime = dto.ExpirationTime,
+                InvoiceTime = dto.InvoiceTime,
+                PosData = dto.PosData,
+                Price = dto.Price,
+                Rate = dto.Rate,
+                Status = dto.Status,
+                BuyerFields = invoice.RefundMail == null ? null : new Newtonsoft.Json.Linq.JObject() { new JProperty("buyerEmail", invoice.RefundMail) }
+            };
+            request.RequestUri = new Uri(invoice.NotificationURL, UriKind.Absolute);
+            request.Content = new StringContent(JsonConvert.SerializeObject(notification), Encoding.UTF8, "application/json");
+            var response = await _Client.SendAsync(request, cancellation);
+            return response;
+        }
+
         int MaxTry = 6;
 
         private static string GetHttpJobId(InvoiceEntity invoice)
         {
             return $"{invoice.Id}-{invoice.Status}-HTTP";
         }
+
+        CompositeDisposable leases = new CompositeDisposable();
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            leases.Add(_EventAggregator.Subscribe<InvoiceStatusChangedEvent>(async e => 
+            {
+                var invoice = await _InvoiceRepository.GetInvoice(null, e.InvoiceId);
+
+                // we need to use the status in the event and not in the invoice. The invoice might now be in another status.
+                if (invoice.FullNotifications)
+                {
+                    if (e.NewState == "expired" ||
+                       e.NewState == "paid" ||
+                       e.NewState == "invalid" ||
+                       e.NewState == "complete"
+                     )
+                        await Notify(invoice);
+                }
+                
+                if(e.NewState == "confirmed")
+                {
+                    await Notify(invoice);
+                }
+            }));
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            leases.Dispose();
+            return Task.CompletedTask;
+        }
     }
 }

BTCPayServer/Services/Invoices/InvoiceWatcher.cs

@@ -13,21 +13,29 @@ using Microsoft.Extensions.Hosting;
 using System.Collections.Concurrent;
 using Hangfire;
 using BTCPayServer.Services.Wallets;
+using BTCPayServer.Controllers;
+using BTCPayServer.Events;
 
 namespace BTCPayServer.Services.Invoices
 {
+    public class InvoiceWatcherAccessor
+    {
+        public InvoiceWatcher Instance { get; set; }
+    }
     public class InvoiceWatcher : IHostedService
     {
         InvoiceRepository _InvoiceRepository;
         ExplorerClient _ExplorerClient;
         DerivationStrategyFactory _DerivationFactory;
-        InvoiceNotificationManager _NotificationManager;
+        EventAggregator _EventAggregator;
         BTCPayWallet _Wallet;
+        
 
         public InvoiceWatcher(ExplorerClient explorerClient,
             InvoiceRepository invoiceRepository,
+            EventAggregator eventAggregator,
             BTCPayWallet wallet,
-            InvoiceNotificationManager notificationManager)
+            InvoiceWatcherAccessor accessor)
         {
             LongPollingMode = explorerClient.Network == Network.RegTest;
             PollInterval = explorerClient.Network == Network.RegTest ? TimeSpan.FromSeconds(10.0) : TimeSpan.FromMinutes(1.0);
@@ -35,22 +43,24 @@ namespace BTCPayServer.Services.Invoices
             _ExplorerClient = explorerClient ?? throw new ArgumentNullException(nameof(explorerClient));
             _DerivationFactory = new DerivationStrategyFactory(_ExplorerClient.Network);
             _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
-            _NotificationManager = notificationManager ?? throw new ArgumentNullException(nameof(notificationManager));
+            _EventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
+            accessor.Instance = this;
         }
+        CompositeDisposable leases = new CompositeDisposable();
 
         public bool LongPollingMode
         {
             get; set;
         }
 
-        public async Task NotifyReceived(Script scriptPubKey)
+        async Task NotifyReceived(Script scriptPubKey)
         {
             var invoice = await _InvoiceRepository.GetInvoiceIdFromScriptPubKey(scriptPubKey);
             if (invoice != null)
                 _WatchRequests.Add(invoice);
         }
 
-        public async Task NotifyBlock()
+        async Task NotifyBlock()
         {
             foreach (var invoice in await _InvoiceRepository.GetPendingInvoices())
             {
@@ -69,17 +79,22 @@ namespace BTCPayServer.Services.Invoices
                     if (invoice == null)
                         break;
                     var stateBefore = invoice.Status;
-                    var result = await UpdateInvoice(changes, invoice).ConfigureAwait(false);
+                    var postSaveActions = new List<Action>();
+                    var result = await UpdateInvoice(changes, invoice, postSaveActions).ConfigureAwait(false);
                     changes = result.Changes;
                     if (result.NeedSave)
+                    { 
                         await _InvoiceRepository.UpdateInvoiceStatus(invoice.Id, invoice.Status, invoice.ExceptionStatus).ConfigureAwait(false);
-
-                    var changed = stateBefore != invoice.Status;
-                    if (changed)
-                    {
-                        Logs.PayServer.LogInformation($"Invoice {invoice.Id}: {stateBefore} => {invoice.Status}");
+                        _EventAggregator.Publish(new InvoiceDataChangedEvent() { InvoiceId = invoice.Id });
                     }
 
+                    var changed = stateBefore != invoice.Status;
+
+                    foreach(var saveAction in postSaveActions)
+                    {
+                        saveAction();
+                    }
+                    
                     if (invoice.Status == "complete" ||
                        ((invoice.Status == "invalid" || invoice.Status == "expired") && invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
                     {
@@ -104,7 +119,7 @@ namespace BTCPayServer.Services.Invoices
         }
 
 
-        private async Task<(bool NeedSave, UTXOChanges Changes)> UpdateInvoice(UTXOChanges changes, InvoiceEntity invoice)
+        private async Task<(bool NeedSave, UTXOChanges Changes)> UpdateInvoice(UTXOChanges changes, InvoiceEntity invoice, List<Action> postSaveActions)
         {
             bool needSave = false;
             //Fetch unknown payments
@@ -123,6 +138,7 @@ namespace BTCPayServer.Services.Invoices
             {
                 var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin).ConfigureAwait(false);
                 invoice.Payments.Add(payment);
+                postSaveActions.Add(() => _EventAggregator.Publish(new InvoicePaymentEvent(invoice.Id)));
                 dirtyAddress = true;
             }
             //////
@@ -131,11 +147,9 @@ namespace BTCPayServer.Services.Invoices
             {
                 needSave = true;
                 await _InvoiceRepository.UnaffectAddress(invoice.Id);
+
+                postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "expired")));
                 invoice.Status = "expired";
-                if (invoice.FullNotifications)
-                {
-                    _NotificationManager.Notify(invoice);
-                }
             }
 
             if (invoice.Status == "new" || invoice.Status == "expired")
@@ -145,11 +159,8 @@ namespace BTCPayServer.Services.Invoices
                 {
                     if (invoice.Status == "new")
                     {
+                        postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "paid")));
                         invoice.Status = "paid";
-                        if (invoice.FullNotifications)
-                        {
-                            _NotificationManager.Notify(invoice);
-                        }
                         invoice.ExceptionStatus = null;
                         await _InvoiceRepository.UnaffectAddress(invoice.Id);
                         needSave = true;
@@ -208,12 +219,9 @@ namespace BTCPayServer.Services.Invoices
                    (chainTotalConfirmed < invoice.GetTotalCryptoDue()))
                 {
                     await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                    postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "invalid")));
                     invoice.Status = "invalid";
                     needSave = true;
-                    if (invoice.FullNotifications)
-                    {
-                        _NotificationManager.Notify(invoice);
-                    }
                 }
                 else
                 {
@@ -221,8 +229,8 @@ namespace BTCPayServer.Services.Invoices
                     if (totalConfirmed >= invoice.GetTotalCryptoDue())
                     {
                         await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                        postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "confirmed")));
                         invoice.Status = "confirmed";
-                        _NotificationManager.Notify(invoice);
                         needSave = true;
                     }
                 }
@@ -235,9 +243,8 @@ namespace BTCPayServer.Services.Invoices
                 var totalConfirmed = transactions.Select(t => t.Payment.Output.Value).Sum();
                 if (totalConfirmed >= invoice.GetTotalCryptoDue())
                 {
+                    postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "complete")));
                     invoice.Status = "complete";
-                    if (invoice.FullNotifications)
-                        _NotificationManager.Notify(invoice);
                     needSave = true;
                 }
             }
@@ -349,6 +356,10 @@ namespace BTCPayServer.Services.Invoices
                     _WatchRequests.Add(pending);
                 }
             }, null, 0, (int)PollInterval.TotalMilliseconds);
+
+            leases.Add(_EventAggregator.Subscribe<NewBlockEvent>(async b => { await NotifyBlock(); }));
+            leases.Add(_EventAggregator.Subscribe<TxOutReceivedEvent>(async b => { await NotifyReceived(b.ScriptPubKey); }));
+
             return Task.CompletedTask;
         }
 
@@ -395,6 +406,7 @@ namespace BTCPayServer.Services.Invoices
 
         public Task StopAsync(CancellationToken cancellationToken)
         {
+            leases.Dispose();
             _UpdatePendingInvoices.Dispose();
             _Cts.Cancel();
             return Task.WhenAny(_RunningTask.Task, Task.Delay(-1, cancellationToken));

BTCPayServer/Services/Rates/CoinAverageRateProvider.cs

@@ -17,61 +17,6 @@ namespace BTCPayServer.Services.Rates
     }
     public class CoinAverageRateProvider : IRateProvider
     {
-        public class RatesJson
-        {
-            public class RateJson
-            {
-                public string Code
-                {
-                    get; set;
-                }
-                public decimal Rate
-                {
-                    get; set;
-                }
-            }
-
-            [JsonProperty("rates")]
-            public JObject RatesInternal
-            {
-                get; set;
-            }
-            [JsonIgnore]
-            public List<RateJson> Rates
-            {
-                get; set;
-            }
-
-            [JsonIgnore]
-            public Dictionary<string, decimal> RatesByCurrency
-            {
-                get; set;
-            }
-
-            public decimal GetRate(string currency)
-            {
-                if (!RatesByCurrency.TryGetValue(currency.ToUpperInvariant(), out decimal currUSD))
-                    throw new RateUnavailableException(currency);
-
-                if (!RatesByCurrency.TryGetValue("BTC", out decimal btcUSD))
-                    throw new RateUnavailableException(currency);
-
-                return currUSD / btcUSD;
-            }
-            public void CalculateDictionary()
-            {
-                RatesByCurrency = new Dictionary<string, decimal>();
-                Rates = new List<RateJson>();
-                foreach (var rate in RatesInternal.OfType<JProperty>())
-                {
-                    var rateJson = new RateJson();
-                    rateJson.Code = rate.Name;
-                    rateJson.Rate = decimal.Parse(rate.Value["rate"].Value<string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint);
-                    RatesByCurrency.Add(rate.Name, rateJson.Rate);
-                    Rates.Add(rateJson);
-                }
-            }
-        }
         static HttpClient _Client = new HttpClient();
 
         public string Market
@@ -80,13 +25,20 @@ namespace BTCPayServer.Services.Rates
         } = "global";
         public async Task<decimal> GetRateAsync(string currency)
         {
-            RatesJson rates = await GetRatesCore();
-            return rates.GetRate(currency);
+            var rates = await GetRatesCore();
+            return GetRate(rates, currency);
         }
 
-        private async Task<RatesJson> GetRatesCore()
+        private decimal GetRate(Dictionary<string, decimal> rates, string currency)
         {
-            var resp = await _Client.GetAsync("https://apiv2.bitcoinaverage.com/constants/exchangerates/" + Market);
+            if (rates.TryGetValue(currency, out decimal result))
+                return result;
+            throw new RateUnavailableException(currency);
+        }
+
+        private async Task<Dictionary<string, decimal>> GetRatesCore()
+        {
+            var resp = await _Client.GetAsync($"https://apiv2.bitcoinaverage.com/indices/{Market}/ticker/short");
             using (resp)
             {
 
@@ -97,19 +49,25 @@ namespace BTCPayServer.Services.Rates
                 if ((int)resp.StatusCode == 403)
                     throw new CoinAverageException("Unauthorized access to the API, premium plan needed");
                 resp.EnsureSuccessStatusCode();
-                var rates = JsonConvert.DeserializeObject<RatesJson>(await resp.Content.ReadAsStringAsync());
-                rates.CalculateDictionary();
-                return rates;
+                var rates = JObject.Parse(await resp.Content.ReadAsStringAsync());
+                return rates.Properties()
+                              .Where(p => p.Name.StartsWith("BTC", StringComparison.OrdinalIgnoreCase))
+                              .ToDictionary(p => p.Name.Substring(3, 3), p => ToDecimal(p.Value["last"]));
             }
         }
 
+        private decimal ToDecimal(JToken token)
+        {
+            return decimal.Parse(token.Value<string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint);
+        }
+
         public async Task<ICollection<Rate>> GetRatesAsync()
         {
-            RatesJson rates = await GetRatesCore();
-            return rates.Rates.Select(o => new Rate()
+            var rates = await GetRatesCore();
+            return rates.Select(o => new Rate()
             {
-                Currency = o.Code,
-                Value = rates.GetRate(o.Code)
+                Currency = o.Key,
+                Value = o.Value
             }).ToList();
         }
     }

BTCPayServer/Services/Rates/FallbackRateProvider.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class FallbackRateProvider : IRateProvider
+    {
+        IRateProvider[] _Providers;
+        public FallbackRateProvider(IRateProvider[] providers)
+        {
+            if (providers == null)
+                throw new ArgumentNullException(nameof(providers));
+            _Providers = providers;
+        }
+        public async Task<decimal> GetRateAsync(string currency)
+        {
+            foreach(var p in _Providers)
+            {
+                try
+                {
+                    return await p.GetRateAsync(currency).ConfigureAwait(false);
+                }
+                catch { }
+            }
+            throw new RateUnavailableException(currency);
+        }
+
+        public async Task<ICollection<Rate>> GetRatesAsync()
+        {
+            foreach (var p in _Providers)
+            {
+                try
+                {
+                    return await p.GetRatesAsync().ConfigureAwait(false);
+                }
+                catch { }
+            }
+            throw new RateUnavailableException("ALL");
+        }
+    }
+}

BTCPayServer/Views/Home/Home.cshtml

@@ -57,10 +57,10 @@
         <h2>Video tutorials</h2>
         <div class="row">
             <div class="col-md-6 text-center">
-                    <iframe width="560" height="315" src="https://www.youtube.com/embed/npFMOu6tTpA" frameborder="0" allowfullscreen></iframe>
+                <iframe width="560" height="315" src="https://www.youtube.com/embed/xh3Eac66qc4" frameborder="0" allowfullscreen></iframe>
             </div>
             <div class="col-md-6 text-center">
-                <iframe width="560" height="315" src="https://www.youtube.com/embed/6rd8ZpLrz-4" frameborder="0" allowfullscreen></iframe>
+                <iframe width="560" height="315" src="https://www.youtube.com/embed/Xo_vApXTZBU" frameborder="0" allowfullscreen></iframe>
             </div>
         </div>
     </div>
@@ -122,10 +122,18 @@
         </div>
         <div class="row">
             <div class="col-lg-4 ml-auto text-center">
-                <a href="http://13.79.159.103:3000/">
+                <a href="http://52.191.212.129:3000/">
                     <img src="~/img/slack.png" height="100" />
                 </a>
-                <p><a href="http://13.79.159.103:3000/">On Slack</a></p>
+                <p><a href="http://52.191.212.129:3000/">On Slack</a></p>
+            </div>
+            <div class="col-lg-4 mr-auto text-center">
+                <a href="https://twitter.com/BtcpayServer">
+                    <img src="~/img/twitter.png" height="100" />
+                </a>
+                <p>
+                    <a href="https://twitter.com/BtcpayServer">On Twitter</a>
+                </p>
             </div>
             <div class="col-lg-4 mr-auto text-center">
                 <a href="https://github.com/btcpayserver/btcpayserver">

BTCPayServer/Views/Invoice/Checkout.cshtml

@@ -26,7 +26,7 @@
     <script src="https://code.jquery.com/jquery-3.2.1.min.js"
             crossorigin="anonymous"></script>
     <script type="text/javascript">
-		@Model.ToSrvModel()
+		@Model.ToJSVariableModel("srvModel")
     </script>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/1.7.1/clipboard.min.js"></script>
     <script src="~/js/vue.js" type="text/javascript" defer="defer"></script>

BTCPayServer/Views/Shared/_Layout.cshtml

@@ -2,6 +2,19 @@
 @inject UserManager<ApplicationUser> UserManager
 @inject RoleManager<IdentityRole> RoleManager
 @inject BTCPayServer.Services.BTCPayServerEnvironment env
+@inject BTCPayServer.NBXplorerWaiterAccessor waiter
+
+@{
+    var waiterState = waiter.Instance.State;
+    var lastStatus = waiter.Instance.LastStatus;
+
+    var synching = waiterState == NBXplorerState.Synching &&
+        lastStatus != null &&
+        lastStatus.NodeBlocks.HasValue &&
+        lastStatus.NodeHeaders.HasValue &&
+        lastStatus.VerificationProgress.HasValue;
+    var verificationProgress = lastStatus != null && lastStatus.VerificationProgress.HasValue ? lastStatus.VerificationProgress.Value * 100 : 0.0;
+}
 
 <!DOCTYPE html>
 <html lang="en">
@@ -78,6 +91,63 @@
     </nav>
 
     @RenderBody()
+
+
+    @if(waiterState == NBXplorerState.NotConnected)
+    {
+        <!-- Modal -->
+        <div id="no-nbxplorer" class="modal fade" role="dialog">
+            <div class="modal-dialog">
+
+                <!-- Modal content-->
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <h4 class="modal-title">NBXplorer is not running</h4>
+                        <button type="button" class="close" data-dismiss="modal">&times;</button>
+                    </div>
+                    <div class="modal-body">
+                        <p>NBXplorer is not running, BTCPay Server will not be functional.</p>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
+                    </div>
+                </div>
+
+            </div>
+        </div>
+    }
+
+    @if(synching)
+    {
+        <!-- Modal -->
+        <div id="synching-modal" class="modal fade" role="dialog">
+            <div class="modal-dialog">
+
+                <!-- Modal content-->
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <h4 class="modal-title">Bitcoin Core node is synching...</h4>
+                        <button type="button" class="close" data-dismiss="modal">&times;</button>
+                    </div>
+                    <div class="modal-body">
+                        <p>Bitcoin Core is synching (Chain height: @lastStatus.NodeHeaders, Block height: @lastStatus.NodeBlocks)</p>
+                        <p>BTCPay Server will not work correctly until it is over.</p>
+                        <div class="progress">
+                            <div class="progress-bar" role="progressbar" aria-valuenow="@((int)verificationProgress)"
+                                 aria-valuemin="0" aria-valuemax="100" style="width:@((int)verificationProgress)%">
+                                @((int)verificationProgress)%
+                            </div>
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
+                    </div>
+                </div>
+
+            </div>
+        </div>
+    }
+
     <footer class="bg-dark">
         <div class="container text-right"><span style="font-size:8px;">@env.ToString()</span></div>
     </footer>
@@ -95,6 +165,23 @@
     <!-- Custom scripts for this template -->
     <script src="~/js/creative.js"></script>
 
+    @if(waiterState == NBXplorerState.NotConnected)
+    {
+        <script type="text/javascript">
+            $(function () {
+                $("#no-nbxplorer").modal();
+            });
+        </script>
+    }
+    @if(synching)
+    {
+        <script type="text/javascript">
+            $(function () {
+                $("#synching-modal").modal();
+            });
+        </script>
+    }
+
     @RenderSection("Scripts", required: false)
 </body>
 

BTCPayServer/wwwroot/js/core.js

@@ -191,7 +191,7 @@ function onDataCallback(jsonData) {
     checkoutCtrl.srvModel = jsonData;
 }
 
-var watcher = setInterval(function () {
+function fetchStatus() {
     var path = srvModel.serverUrl + "/i/" + srvModel.invoiceId + "/status";
     $.ajax({
         url: path,
@@ -201,6 +201,27 @@ var watcher = setInterval(function () {
     }).fail(function (jqXHR, textStatus, errorThrown) {
 
     });
+}
+
+var supportsWebSockets = 'WebSocket' in window && window.WebSocket.CLOSING === 2;
+if (supportsWebSockets) {
+    var path = srvModel.serverUrl + "/i/" + srvModel.invoiceId + "/status/ws";
+    path = path.replace("https://", "wss://");
+    path = path.replace("http://", "ws://");
+    try {
+        var socket = new WebSocket(path);
+        socket.onmessage = function (e) {
+            fetchStatus();
+        };
+    }
+    catch
+    {
+        console.error("Error while connecting to websocket for invoice notifictions");
+    }
+}
+
+var watcher = setInterval(function () {
+    fetchStatus();
 }, 2000);
 
 $(".menu__item").click(function () {

Dockerfile

@@ -6,7 +6,7 @@ RUN dotnet restore
 COPY BTCPayServer/. .
 RUN dotnet publish --output /app/ --configuration Release
 
-FROM microsoft/aspnetcore:2.0.0
+FROM microsoft/aspnetcore:2.0.3
 WORKDIR /app
 
 RUN mkdir /datadir
@@ -14,4 +14,4 @@ ENV BTCPAY_DATADIR=/datadir
 VOLUME /datadir
 
 COPY --from=builder "/app" .
-ENTRYPOINT ["dotnet", "BTCPayServer.dll"]
+ENTRYPOINT ["dotnet", "BTCPayServer.dll"]