Fix #38 with paidOver + paidLate

Resolving problems with Vue console warnings

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -43,21 +43,15 @@ namespace BTCPayServer.Tests
         {
             get; set;
         }
-        public string CookieFile
-        {
-            get; set;
-        }
+
+        public Uri LTCNBXplorerUri { get; set; }
+        
         public Uri ServerUri
         {
             get;
             set;
         }
 
-        public ExtKey HDPrivateKey
-        {
-            get; set;
-        }
-
         public string Postgres
         {
             get; set;
@@ -73,27 +67,42 @@ namespace BTCPayServer.Tests
         {
             if (!Directory.Exists(_Directory))
                 Directory.CreateDirectory(_Directory);
+            string chain = ChainType.Regtest.ToNetwork().Name;
+            string chainDirectory = Path.Combine(_Directory, chain);
+            if (!Directory.Exists(chainDirectory))
+                Directory.CreateDirectory(chainDirectory);
+
 
-            HDPrivateKey = new ExtKey();
             StringBuilder config = new StringBuilder();
-            config.AppendLine($"regtest=1");
+            config.AppendLine($"{chain.ToLowerInvariant()}=1");
             config.AppendLine($"port={Port}");
-            config.AppendLine($"explorer.url={NBXplorerUri.AbsoluteUri}");
-            config.AppendLine($"explorer.cookiefile={CookieFile}");
-            config.AppendLine($"hdpubkey={HDPrivateKey.Neuter().ToString(Network.RegTest)}");
+            config.AppendLine($"chains=btc,ltc");
+
+            config.AppendLine($"btc.explorer.url={NBXplorerUri.AbsoluteUri}");
+            config.AppendLine($"btc.explorer.cookiefile=0");
+
+            config.AppendLine($"ltc.explorer.url={LTCNBXplorerUri.AbsoluteUri}");
+            config.AppendLine($"ltc.explorer.cookiefile=0");
+
             if (Postgres != null)
                 config.AppendLine($"postgres=" + Postgres);
-            File.WriteAllText(Path.Combine(_Directory, "settings.config"), config.ToString());
+            var confPath = Path.Combine(chainDirectory, "settings.config");
+            File.WriteAllText(confPath, config.ToString());
 
             ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
 
-            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory });
+            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath });
 
             _Host = new WebHostBuilder()
                     .UseConfiguration(conf)
                     .ConfigureServices(s =>
                     {
-                        s.AddSingleton<IRateProvider>(new MockRateProvider(new Rate("USD", 5000m)));
+                        var mockRates = new MockRateProviderFactory();
+                        var btc = new MockRateProvider("BTC", new Rate("USD", 5000m));
+                        var ltc = new MockRateProvider("LTC", new Rate("USD", 500m));
+                        mockRates.AddMock(btc);
+                        mockRates.AddMock(ltc);
+                        s.AddSingleton<IRateProviderFactory>(mockRates);
                         s.AddLogging(l =>
                         {
                             l.SetMinimumLevel(LogLevel.Information)
@@ -107,12 +116,6 @@ namespace BTCPayServer.Tests
                     .Build();
             _Host.Start();
             InvoiceRepository = (InvoiceRepository)_Host.Services.GetService(typeof(InvoiceRepository));
-
-            var waiter = ((NBXplorerWaiterAccessor)_Host.Services.GetService(typeof(NBXplorerWaiterAccessor))).Instance;
-            while(waiter.State != NBXplorerState.Ready)
-            {
-                Thread.Sleep(10);
-            }
         }
         
         public string HostName

BTCPayServer.Tests/Dockerfile

@@ -1,4 +1,4 @@
-FROM microsoft/dotnet:2.0.0-sdk
+FROM microsoft/dotnet:2.0.5-sdk-2.1.4
 WORKDIR /app
  # caches restore result by copying csproj file separately
 COPY BTCPayServer.Tests/BTCPayServer.Tests.csproj BTCPayServer.Tests/BTCPayServer.Tests.csproj

BTCPayServer.Tests/EclairTester.cs

@@ -12,7 +12,7 @@ namespace BTCPayServer.Tests
         public EclairTester(ServerTester parent, string environmentName, string defaultRPC, string defaultHost)
         {
             this.parent = parent;
-            RPC = new EclairRPCClient(new Uri(parent.GetEnvironment(environmentName, defaultRPC)), parent.Network);
+            //RPC = new EclairRPCClient(new Uri(parent.GetEnvironment(environmentName, defaultRPC)), parent.Network);
             P2PHost = parent.GetEnvironment(environmentName + "_HOST", defaultHost);
         }
 

BTCPayServer.Tests/ServerTester.cs

@@ -47,12 +47,17 @@ namespace BTCPayServer.Tests
                 Directory.CreateDirectory(_Directory);
 
 
-            FakeCallback = bool.Parse(GetEnvironment("TESTS_FAKECALLBACK", "true"));
-            ExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_RPCCONNECTION", "server=http://127.0.0.1:43782;ceiwHEbqWI83:DwubwWsoo3")), Network);
-            ExplorerClient = new ExplorerClient(Network, new Uri(GetEnvironment("TESTS_NBXPLORERURL", "http://127.0.0.1:32838/")));
+            NetworkProvider = new BTCPayNetworkProvider(ChainType.Regtest);
+            ExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_BTCRPCCONNECTION", "server=http://127.0.0.1:43782;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("BTC").NBitcoinNetwork);
+            LTCExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_LTCRPCCONNECTION", "server=http://127.0.0.1:43783;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("LTC").NBitcoinNetwork);
+
+            ExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("BTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_BTCNBXPLORERURL", "http://127.0.0.1:32838/")));
+            LTCExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("LTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_LTCNBXPLORERURL", "http://127.0.0.1:32838/")));
+
             PayTester = new BTCPayServerTester(Path.Combine(_Directory, "pay"))
             {
                 NBXplorerUri = ExplorerClient.Address,
+                LTCNBXplorerUri = LTCExplorerClient.Address,
                 Postgres = GetEnvironment("TESTS_POSTGRES", "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver")
             };
             PayTester.Port = int.Parse(GetEnvironment("TESTS_PORT", Utils.FreeTcpPort().ToString()));
@@ -104,20 +109,22 @@ namespace BTCPayServer.Tests
             return new TestAccount(this);
         }
 
-        public bool FakeCallback
-        {
-            get;
-            set;
-        }
+        public BTCPayNetworkProvider NetworkProvider { get; private set; }
         public RPCClient ExplorerNode
         {
             get; set;
         }
 
+        public RPCClient LTCExplorerNode
+        {
+            get; set;
+        }
+
         public ExplorerClient ExplorerClient
         {
             get; set;
         }
+        public ExplorerClient LTCExplorerClient { get; set; }
 
         HttpClient _Http = new HttpClient();
 
@@ -213,55 +220,12 @@ namespace BTCPayServer.Tests
             }
         }
 
-        /// <summary>
-        /// Simulating callback from NBXplorer. NBXplorer can't reach the host during tests as it is not running on localhost.
-        /// </summary>
-        /// <param name="address"></param>
-        public void SimulateCallback(BitcoinAddress address = null)
-        {
-            if (!FakeCallback) //The callback of NBXplorer should work
-                return;
-
-            var req = new MockHttpRequest(PayTester.ServerUri);
-            var controller = PayTester.GetController<CallbackController>();
-            if (address != null)
-            {
-
-                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().GetAwaiter().GetResult();
-
-                HttpRequestMessage message = new HttpRequestMessage();
-                message.Method = HttpMethod.Post;
-                message.RequestUri = uri;
-                message.Content = content;
-
-                _Http.SendAsync(message).GetAwaiter().GetResult();
-            }
-            else
-            {
-
-                var uri = controller.GetCallbackBlockUriAsync().GetAwaiter().GetResult();
-                HttpRequestMessage message = new HttpRequestMessage();
-                message.Method = HttpMethod.Post;
-                message.RequestUri = uri;
-                _Http.SendAsync(message).GetAwaiter().GetResult();
-            }
-        }
-
 
         public BTCPayServerTester PayTester
         {
             get; set;
         }
 
-        public Network Network
-        {
-            get;
-            set;
-        } = Network.RegTest;
-
         public void Dispose()
         {
             if (PayTester != null)

BTCPayServer.Tests/TestAccount.cs

@@ -46,25 +46,53 @@ namespace BTCPayServer.Tests
             Assert.IsType<ViewResult>(await store.RequestPairing(pairingCode.ToString()));
             await store.Pair(pairingCode.ToString(), StoreId);
         }
-        public StoresController CreateStore()
+        public StoresController CreateStore(string cryptoCode = null)
         {
-            return CreateStoreAsync().GetAwaiter().GetResult();
+            return CreateStoreAsync(cryptoCode).GetAwaiter().GetResult();
         }
-        public async Task<StoresController> CreateStoreAsync()
+
+        public string CryptoCode { get; set; } = "BTC";
+        public async Task<StoresController> CreateStoreAsync(string cryptoCode = null)
         {
-            ExtKey = new ExtKey().GetWif(parent.Network);
+            cryptoCode = cryptoCode ?? CryptoCode;
+            SupportedNetwork = parent.NetworkProvider.GetNetwork(cryptoCode);
+            ExtKey = new ExtKey().GetWif(SupportedNetwork.NBitcoinNetwork);
             var store = parent.PayTester.GetController<StoresController>(UserId);
             await store.CreateStore(new CreateStoreViewModel() { Name = "Test Store" });
             StoreId = store.CreatedStoreId;
-            DerivationScheme = new DerivationStrategyFactory(parent.Network).Parse(ExtKey.Neuter().ToString() + "-[legacy]");
-            await store.UpdateStore(StoreId, new StoreViewModel()
+            DerivationScheme = new DerivationStrategyFactory(SupportedNetwork.NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + "-[legacy]");
+            var vm = (StoreViewModel)((ViewResult)await store.UpdateStore(StoreId)).Model;
+            vm.SpeedPolicy = SpeedPolicy.MediumSpeed;
+            await store.UpdateStore(StoreId, vm);
+
+            await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
             {
+                CryptoCurrency = cryptoCode,
+                DerivationSchemeFormat = "BTCPay",
                 DerivationScheme = DerivationScheme.ToString(),
-                SpeedPolicy = SpeedPolicy.MediumSpeed
             }, "Save");
             return store;
         }
 
+        public BTCPayNetwork SupportedNetwork { get; set; }
+
+        public void RegisterDerivationScheme(string crytoCode)
+        {
+            RegisterDerivationSchemeAsync(crytoCode).GetAwaiter().GetResult();
+        }
+        public async Task RegisterDerivationSchemeAsync(string crytoCode)
+        {
+            var store = parent.PayTester.GetController<StoresController>(UserId);
+            var networkProvider = parent.PayTester.GetService<BTCPayNetworkProvider>();
+            var derivation = new DerivationStrategyFactory(networkProvider.GetNetwork(crytoCode).NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + "-[legacy]");
+            await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
+            {
+                CryptoCurrency = crytoCode,
+                DerivationSchemeFormat = crytoCode,
+                DerivationScheme = derivation.ToString(),
+            }, "Save");
+        }
+
         public DerivationStrategyBase DerivationScheme { get; set; }
 
         private async Task RegisterAsync()

BTCPayServer.Tests/UnitTest1.cs

@@ -23,6 +23,9 @@ using Microsoft.EntityFrameworkCore;
 using BTCPayServer.Services.Rates;
 using Microsoft.Extensions.Caching.Memory;
 using BTCPayServer.Eclair;
+using System.Collections.Generic;
+using BTCPayServer.Models.StoreViewModels;
+using System.Threading.Tasks;
 
 namespace BTCPayServer.Tests
 {
@@ -42,11 +45,19 @@ namespace BTCPayServer.Tests
             entity.TxFee = Money.Coins(0.1m);
             entity.Rate = 5000;
 
-            var cryptoData = entity.GetCryptoData("BTC");
-            Assert.NotNull(cryptoData); // Should use legacy data to build itself
             entity.Payments = new System.Collections.Generic.List<PaymentEntity>();
             entity.ProductInformation = new ProductInformation() { Price = 5000 };
 
+            // Some check that handling legacy stuff does not break things
+            var cryptoData = entity.GetCryptoData("BTC", null, true);
+            cryptoData.Calculate();
+            Assert.NotNull(cryptoData);
+            Assert.Null(entity.GetCryptoData("BTC", null, false));
+            entity.SetCryptoData(new CryptoData() { ParentEntity = entity, Rate = entity.Rate, CryptoCode = "BTC", TxFee = entity.TxFee });
+            Assert.NotNull(entity.GetCryptoData("BTC", null, false));
+            Assert.NotNull(entity.GetCryptoData("BTC", null, true));
+            ////////////////////
+
             var accounting = cryptoData.Calculate();
             Assert.Equal(Money.Coins(1.1m), accounting.Due);
             Assert.Equal(Money.Coins(1.1m), accounting.TotalDue);
@@ -75,6 +86,88 @@ namespace BTCPayServer.Tests
             accounting = cryptoData.Calculate();
             Assert.Equal(Money.Zero, accounting.Due);
             Assert.Equal(Money.Coins(1.3m), accounting.TotalDue);
+
+            entity = new InvoiceEntity();
+            entity.ProductInformation = new ProductInformation() { Price = 5000 };
+            entity.SetCryptoData(new System.Collections.Generic.Dictionary<string, CryptoData>(new KeyValuePair<string, CryptoData>[] {
+                new KeyValuePair<string,CryptoData>("BTC", new CryptoData()
+                                                           {
+                                                                Rate = 1000,
+                                                                TxFee = Money.Coins(0.1m)
+                                                           }),
+                new KeyValuePair<string,CryptoData>("LTC", new CryptoData()
+                                                           {
+                                                                Rate = 500,
+                                                                TxFee = Money.Coins(0.01m)
+                                                           })
+            }));
+            entity.Payments = new List<PaymentEntity>();
+            cryptoData = entity.GetCryptoData("BTC", null);
+            accounting = cryptoData.Calculate();
+            Assert.Equal(Money.Coins(5.1m), accounting.Due);
+
+            cryptoData = entity.GetCryptoData("LTC", null);
+            accounting = cryptoData.Calculate();
+            Assert.Equal(Money.Coins(10.01m), accounting.TotalDue);
+
+            entity.Payments.Add(new PaymentEntity() { CryptoCode = "BTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true });
+
+            cryptoData = entity.GetCryptoData("BTC", null);
+            accounting = cryptoData.Calculate();
+            Assert.Equal(Money.Coins(4.2m), accounting.Due);
+            Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
+            Assert.Equal(Money.Coins(1.0m), accounting.Paid);
+            Assert.Equal(Money.Coins(5.2m), accounting.TotalDue);
+            Assert.Equal(2, accounting.TxCount);
+
+            cryptoData = entity.GetCryptoData("LTC", null);
+            accounting = cryptoData.Calculate();
+            Assert.Equal(Money.Coins(10.01m + 0.1m * 2 - 2.0m /* 8.21m */), accounting.Due);
+            Assert.Equal(Money.Coins(0.0m), accounting.CryptoPaid);
+            Assert.Equal(Money.Coins(2.0m), accounting.Paid);
+            Assert.Equal(Money.Coins(10.01m + 0.1m * 2), accounting.TotalDue);
+
+            entity.Payments.Add(new PaymentEntity() { CryptoCode = "LTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true });
+
+
+            cryptoData = entity.GetCryptoData("BTC", null);
+            accounting = cryptoData.Calculate();
+            Assert.Equal(Money.Coins(4.2m - 0.5m + 0.01m / 2), accounting.Due);
+            Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
+            Assert.Equal(Money.Coins(1.5m), accounting.Paid);
+            Assert.Equal(Money.Coins(5.2m + 0.01m / 2), accounting.TotalDue); // The fee for LTC added
+            Assert.Equal(2, accounting.TxCount);
+
+            cryptoData = entity.GetCryptoData("LTC", null);
+            accounting = cryptoData.Calculate();
+            Assert.Equal(Money.Coins(8.21m - 1.0m + 0.01m), accounting.Due);
+            Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
+            Assert.Equal(Money.Coins(3.0m), accounting.Paid);
+            Assert.Equal(Money.Coins(10.01m + 0.1m * 2 + 0.01m), accounting.TotalDue);
+            Assert.Equal(2, accounting.TxCount);
+
+            var remaining = Money.Coins(4.2m - 0.5m + 0.01m / 2);
+            entity.Payments.Add(new PaymentEntity() { CryptoCode = "BTC", Output = new TxOut(remaining, new Key()), Accounted = true });
+
+            cryptoData = entity.GetCryptoData("BTC", null);
+            accounting = cryptoData.Calculate();
+            Assert.Equal(Money.Zero, accounting.Due);
+            Assert.Equal(Money.Coins(1.0m) + remaining, accounting.CryptoPaid);
+            Assert.Equal(Money.Coins(1.5m) + remaining, accounting.Paid);
+            Assert.Equal(Money.Coins(5.2m + 0.01m / 2), accounting.TotalDue);
+            Assert.Equal(accounting.Paid, accounting.TotalDue);
+            Assert.Equal(2, accounting.TxCount);
+
+            cryptoData = entity.GetCryptoData("LTC", null);
+            accounting = cryptoData.Calculate();
+            Assert.Equal(Money.Zero, accounting.Due);
+            Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
+            Assert.Equal(Money.Coins(3.0m) + remaining * 2, accounting.Paid);
+            // Paying 2 BTC fee, LTC fee removed because fully paid
+            Assert.Equal(Money.Coins(10.01m + 0.1m * 2 + 0.1m * 2 /* + 0.01m no need to pay this fee anymore */), accounting.TotalDue);
+            Assert.Equal(1, accounting.TxCount);
+            Assert.Equal(accounting.Paid, accounting.TotalDue);
+
 #pragma warning restore CS0618
         }
 
@@ -119,7 +212,6 @@ namespace BTCPayServer.Tests
 
                 Eventually(() =>
                 {
-                    tester.SimulateCallback(url.Address);
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("paid", localInvoice.Status);
                     Assert.True(localInvoice.Refundable);
@@ -188,12 +280,12 @@ namespace BTCPayServer.Tests
                         OrderId = "orderId",
                         NotificationURL = callbackServer.GetUri().AbsoluteUri,
                         ItemDesc = "Some description",
-                        FullNotifications = true
+                        FullNotifications = true,
+                        ExtendedNotifications = true
                     });
                     BitcoinUrlBuilder url = new BitcoinUrlBuilder(invoice.PaymentUrls.BIP21);
                     tester.ExplorerNode.SendToAddress(url.Address, url.Amount);
                     Thread.Sleep(5000);
-                    tester.SimulateCallback(url.Address);
                     callbackServer.ProcessNextRequest((ctx) =>
                     {
                         var ipn = new StreamReader(ctx.Request.Body).ReadToEnd();
@@ -249,14 +341,13 @@ namespace BTCPayServer.Tests
                     false, //subtractfeefromamount
                     true, //replaceable
                 }).ResultString);
-                var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, tester.Network);
+                var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, user.SupportedNetwork.NBitcoinNetwork);
 
                 Eventually(() =>
                 {
-                    tester.SimulateCallback(invoiceAddress);
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(payment1, invoice.BtcPaid);
-                    invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, tester.Network);
+                    invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, user.SupportedNetwork.NBitcoinNetwork);
                 });
 
                 var tx = tester.ExplorerNode.GetRawTransaction(new uint256(tx1));
@@ -271,10 +362,9 @@ namespace BTCPayServer.Tests
                 change.Value -= (payment2 - payment1) * 2; //Add more fees
                 var replaced = tester.ExplorerNode.SignRawTransaction(tx);
                 tester.ExplorerNode.SendRawTransaction(replaced);
-                var test = tester.ExplorerClient.Sync(user.DerivationScheme, null);
+                var test = tester.ExplorerClient.GetUTXOs(user.DerivationScheme, null);
                 Eventually(() =>
                 {
-                    tester.SimulateCallback(invoiceAddress);
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(payment2, invoice.BtcPaid);
                 });
@@ -293,7 +383,7 @@ namespace BTCPayServer.Tests
         }
 
         [Fact]
-        public void InvoiceFlowThroughDifferentStatesCorrectly()
+        public void TestAccessBitpayAPI()
         {
             using (var tester = ServerTester.Create())
             {
@@ -302,14 +392,215 @@ namespace BTCPayServer.Tests
                 Assert.False(user.BitPay.TestAccess(Facade.Merchant));
                 user.GrantAccess();
                 Assert.True(user.BitPay.TestAccess(Facade.Merchant));
+            }
+        }
+
+
+        [Fact]
+        public void CanTweakRate()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+
+
+                // First we try payment with a merchant having only BTC
+                var invoice1 = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 5000.0,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+
+                var storeController = tester.PayTester.GetController<StoresController>(user.UserId);
+                var vm = (StoreViewModel)((ViewResult)storeController.UpdateStore(user.StoreId).Result).Model;
+                Assert.Equal(1.0, vm.RateMultiplier);
+                vm.RateMultiplier = 0.5;
+                storeController.UpdateStore(user.StoreId, vm).Wait();
+
+
+                var invoice2 = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 5000.0,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                Assert.True(invoice2.BtcPrice.Almost(invoice1.BtcPrice * 2, 0.00001m));
+            }
+        }
+
+        [Fact]
+        public void CanHaveLTCOnlyStore()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.CryptoCode = "LTC";
+                user.GrantAccess();
+
+                // First we try payment with a merchant having only BTC
+                var invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 500,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                Assert.Single(invoice.CryptoInfo);
+                Assert.Equal("LTC", invoice.CryptoInfo[0].CryptoCode);
+                var cashCow = tester.LTCExplorerNode;
+                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
+                var firstPayment = Money.Coins(0.1m);
+                cashCow.SendToAddress(invoiceAddress, firstPayment);
+                Eventually(() =>
+                {
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal(firstPayment, invoice.CryptoInfo[0].Paid);
+                });
+
+                Assert.Single(invoice.CryptoInfo); // Only BTC should be presented
+
+                var controller = tester.PayTester.GetController<InvoiceController>(null);
+                var checkout = (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id, null).GetAwaiter().GetResult()).Value;
+                Assert.Single(checkout.AvailableCryptos);
+                Assert.Equal("LTC", checkout.CryptoCode);
+
+                //////////////////////
+
+                // Despite it is called BitcoinAddress it should be LTC because BTC is not available
+                Assert.Null(invoice.BitcoinAddress);
+                Assert.NotEqual(1.0, invoice.Rate);
+                Assert.NotEqual(invoice.BtcDue, invoice.CryptoInfo[0].Due); // Should be BTC rate
+                cashCow.SendToAddress(invoiceAddress, invoice.CryptoInfo[0].Due);
+
+                Eventually(() =>
+                {
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal("paid", invoice.Status);
+                    checkout = (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id, null).GetAwaiter().GetResult()).Value;
+                    Assert.Equal("paid", checkout.Status);
+                });
+
+            }
+        }
+
+        [Fact]
+        public void CanPayWithTwoCurrencies()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+
+                // First we try payment with a merchant having only BTC
+                var invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 5000.0,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                var cashCow = tester.ExplorerNode;
+                cashCow.Generate(2); // get some money in case
+                var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
+                var firstPayment = Money.Coins(0.04m);
+                cashCow.SendToAddress(invoiceAddress, firstPayment);
+                Eventually(() =>
+                {
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.True(invoice.BtcPaid == firstPayment);
+                });
+
+                Assert.Single(invoice.CryptoInfo); // Only BTC should be presented
+
+                var controller = tester.PayTester.GetController<InvoiceController>(null);
+                var checkout = (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id, null).GetAwaiter().GetResult()).Value;
+                Assert.Single(checkout.AvailableCryptos);
+                Assert.Equal("BTC", checkout.CryptoCode);
+
+                //////////////////////
+
+                // Retry now with LTC enabled
+                user.RegisterDerivationScheme("LTC");
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 5000.0,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                cashCow = tester.ExplorerNode;
+                invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
+                firstPayment = Money.Coins(0.04m);
+                cashCow.SendToAddress(invoiceAddress, firstPayment);
+                Logs.Tester.LogInformation("First payment sent to " + invoiceAddress);
+                Eventually(() =>
+                {
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.True(invoice.BtcPaid == firstPayment);
+                });
+
+                cashCow = tester.LTCExplorerNode;
+                var ltcCryptoInfo = invoice.CryptoInfo.FirstOrDefault(c => c.CryptoCode == "LTC");
+                Assert.NotNull(ltcCryptoInfo);
+                invoiceAddress = BitcoinAddress.Create(ltcCryptoInfo.Address, cashCow.Network);
+                var secondPayment = Money.Coins(decimal.Parse(ltcCryptoInfo.Due));
+                cashCow.Generate(2); // LTC is not worth a lot, so just to make sure we have money...
+                cashCow.SendToAddress(invoiceAddress, secondPayment);
+                Logs.Tester.LogInformation("Second payment sent to " + invoiceAddress);
+                Eventually(() =>
+                {
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal(Money.Zero, invoice.BtcDue);
+                    var ltcPaid = invoice.CryptoInfo.First(c => c.CryptoCode == "LTC");
+                    Assert.Equal(Money.Zero, ltcPaid.Due);
+                    Assert.Equal(secondPayment, ltcPaid.CryptoPaid);
+                    Assert.Equal("paid", invoice.Status);
+                    Assert.False((bool)((JValue)invoice.ExceptionStatus).Value);
+                });
+
+                controller = tester.PayTester.GetController<InvoiceController>(null);
+                checkout = (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id, "LTC").GetAwaiter().GetResult()).Value;
+                Assert.Equal(2, checkout.AvailableCryptos.Count);
+                Assert.Equal("LTC", checkout.CryptoCode);
+            }
+        }
+
+        [Fact]
+        public void InvoiceFlowThroughDifferentStatesCorrectly()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 5000.0,
                     Currency = "USD",
                     PosData = "posData",
                     OrderId = "orderId",
-                    //RedirectURL = redirect + "redirect",
-                    //NotificationURL = CallbackUri + "/notification",
                     ItemDesc = "Some description",
                     FullNotifications = true
                 }, Facade.Merchant);
@@ -366,7 +657,6 @@ namespace BTCPayServer.Tests
 
                 Eventually(() =>
                 {
-                    tester.SimulateCallback(invoiceAddress);
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("new", localInvoice.Status);
                     Assert.Equal(firstPayment, localInvoice.BtcPaid);
@@ -377,9 +667,9 @@ namespace BTCPayServer.Tests
                     Assert.True(IsMapped(localInvoice, ctx));
 
                     invoiceEntity = repo.GetInvoice(null, invoice.Id, true).GetAwaiter().GetResult();
-                    var historical1 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.Address == invoice.BitcoinAddress.ToString());
+                    var historical1 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.GetAddress() == invoice.BitcoinAddress.ToString());
                     Assert.NotNull(historical1.UnAssigned);
-                    var historical2 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.Address == localInvoice.BitcoinAddress.ToString());
+                    var historical2 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.GetAddress() == localInvoice.BitcoinAddress.ToString());
                     Assert.Null(historical2.UnAssigned);
                     invoiceAddress = BitcoinAddress.Create(localInvoice.BitcoinAddress, cashCow.Network);
                     secondPayment = localInvoice.BtcDue;
@@ -389,7 +679,6 @@ namespace BTCPayServer.Tests
 
                 Eventually(() =>
                 {
-                    tester.SimulateCallback(invoiceAddress);
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("paid", localInvoice.Status);
                     Assert.Equal(firstPayment + secondPayment, localInvoice.BtcPaid);
@@ -403,7 +692,6 @@ namespace BTCPayServer.Tests
 
                 Eventually(() =>
                 {
-                    tester.SimulateCallback();
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("confirmed", localInvoice.Status);
                 });
@@ -412,7 +700,6 @@ namespace BTCPayServer.Tests
 
                 Eventually(() =>
                 {
-                    tester.SimulateCallback();
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("complete", localInvoice.Status);
                     Assert.NotEqual(0.0, localInvoice.Rate);
@@ -435,7 +722,6 @@ namespace BTCPayServer.Tests
 
                 Eventually(() =>
                 {
-                    tester.SimulateCallback(invoiceAddress);
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("paid", localInvoice.Status);
                     Assert.Equal(Money.Zero, localInvoice.BtcDue);
@@ -446,7 +732,6 @@ namespace BTCPayServer.Tests
 
                 Eventually(() =>
                 {
-                    tester.SimulateCallback();
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("confirmed", localInvoice.Status);
                     Assert.Equal(Money.Zero, localInvoice.BtcDue);
@@ -458,27 +743,31 @@ namespace BTCPayServer.Tests
         [Fact]
         public void CheckRatesProvider()
         {
-            var coinAverage = new CoinAverageRateProvider();
+            var coinAverage = new CoinAverageRateProvider("BTC");
             var jpy = coinAverage.GetRateAsync("JPY").GetAwaiter().GetResult();
             var jpy2 = new BitpayRateProvider(new Bitpay(new Key(), new Uri("https://bitpay.com/"))).GetRateAsync("JPY").GetAwaiter().GetResult();
 
-            var cached = new CachedRateProvider(coinAverage, new MemoryCache(new MemoryCacheOptions() { ExpirationScanFrequency = TimeSpan.FromSeconds(1.0) }));
+            var cached = new CachedRateProvider("BTC", coinAverage, new MemoryCache(new MemoryCacheOptions() { ExpirationScanFrequency = TimeSpan.FromSeconds(1.0) }));
             cached.CacheSpan = TimeSpan.FromSeconds(10);
             var a = cached.GetRateAsync("JPY").GetAwaiter().GetResult();
             var b = cached.GetRateAsync("JPY").GetAwaiter().GetResult();
             //Manually check that cache get hit after 10 sec
             var c = cached.GetRateAsync("JPY").GetAwaiter().GetResult();
+
+            var bitstamp = new CoinAverageRateProvider("BTC") { Exchange = "bitstamp" };
+            var bitstampRate = bitstamp.GetRateAsync("USD").GetAwaiter().GetResult();
+            Assert.Throws<RateUnavailableException>(() => bitstamp.GetRateAsync("XXXXX").GetAwaiter().GetResult());
         }
 
         private static bool IsMapped(Invoice invoice, ApplicationDbContext ctx)
         {
-            var h = BitcoinAddress.Create(invoice.BitcoinAddress).ScriptPubKey.Hash.ToString();
-            return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.Address == h) != null;
+            var h = BitcoinAddress.Create(invoice.BitcoinAddress).ScriptPubKey.Hash;
+            return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.GetHash() == h) != null;
         }
 
         private void Eventually(Action act)
         {
-            CancellationTokenSource cts = new CancellationTokenSource(10000);
+            CancellationTokenSource cts = new CancellationTokenSource(20000);
             while (true)
             {
                 try

BTCPayServer.Tests/docker-compose.yml

@@ -1,4 +1,4 @@
-version: "3"
+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,
@@ -10,21 +10,18 @@ services:
       context: ..
       dockerfile: BTCPayServer.Tests/Dockerfile
     environment:
-      TESTS_RPCCONNECTION: server=http://bitcoind:43782;ceiwHEbqWI83:DwubwWsoo3
-      TESTS_NBXPLORERURL: http://nbxplorer:32838/
+      TESTS_BTCRPCCONNECTION: server=http://bitcoind:43782;ceiwHEbqWI83:DwubwWsoo3
+      TESTS_LTCRPCCONNECTION: server=http://litecoind:43782;ceiwHEbqWI83:DwubwWsoo3
+      TESTS_BTCNBXPLORERURL: http://nbxplorer:32838/
+      TESTS_LTCNBXPLORERURL: http://nbxplorer:32838/
       TESTS_POSTGRES: User ID=postgres;Host=postgres;Port=5432;Database=btcpayserver
-      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
+      - postgres
     extra_hosts: 
       - "tests:127.0.0.1"
 
@@ -36,71 +33,32 @@ services:
         regtest=1
         connect=bitcoind:39388
     links:
-      - bitcoind
       - nbxplorer
-      # - eclair1
-      # - eclair2
+      - postgres
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.0.34
+    image: nicolasdorier/nbxplorer:1.0.1.3
     ports:
       - "32838:32838"
     expose: 
       - "32838"
     environment:
       NBXPLORER_NETWORK: regtest
-      NBXPLORER_RPCURL: http://bitcoind:43782/
-      NBXPLORER_RPCUSER: ceiwHEbqWI83
-      NBXPLORER_RPCPASSWORD: DwubwWsoo3
-      NBXPLORER_NODEENDPOINT: bitcoind:39388
+      NBXPLORER_CHAINS: "btc,ltc"
+      NBXPLORER_BTCRPCURL: http://bitcoind:43782/
+      NBXPLORER_BTCNODEENDPOINT: bitcoind:39388
+      NBXPLORER_BTCRPCUSER: ceiwHEbqWI83
+      NBXPLORER_BTCRPCPASSWORD: DwubwWsoo3
+      NBXPLORER_LTCRPCURL: http://litecoind:43782/
+      NBXPLORER_LTCNODEENDPOINT: litecoind:39388
+      NBXPLORER_LTCRPCUSER: ceiwHEbqWI83
+      NBXPLORER_LTCRPCPASSWORD: DwubwWsoo3
       NBXPLORER_BIND: 0.0.0.0:32838
       NBXPLORER_VERBOSE: 1
       NBXPLORER_NOAUTH: 1
     links:
       - bitcoind
-      - postgres
-
-  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
+      - litecoind
 
   bitcoind:
     container_name: btcpayserver_dev_bitcoind
@@ -114,15 +72,29 @@ services:
         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
+    ports: 
+      - "43782:43782"
+    expose:
+      - "43782" # RPC
+      - "39388" # P2P
+
+  litecoind:
+    container_name: btcpayserver_dev_litecoind
+    image: nicolasdorier/docker-litecoin:0.14.2
+    environment:
+      BITCOIN_EXTRA_ARGS: |
+        rpcuser=ceiwHEbqWI83
+        rpcpassword=DwubwWsoo3
+        regtest=1
+        server=1
+        rpcport=43782
+        port=39388
+        whitelist=0.0.0.0/0
+    ports: 
+      - "43783:43782"
     expose:
       - "43782" # RPC
       - "39388" # P2P
-      - "29000" # zmq
 
   postgres:
     image:  postgres:9.6.5

BTCPayServer.Tests/docker-litecoin-cli.ps1

@@ -0,0 +1 @@
+docker exec -ti btcpayserver_dev_litecoind litecoin-cli -regtest -conf="/data/litecoin.conf" -datadir="/data" $args

BTCPayServer/BTCPayNetwork.cs

@@ -1,16 +1,73 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
 using NBitcoin;
+using NBXplorer;
 
 namespace BTCPayServer
 {
+    public class BTCPayDefaultSettings
+    {
+        static BTCPayDefaultSettings()
+        {
+            _Settings = new Dictionary<ChainType, BTCPayDefaultSettings>();
+            foreach (var chainType in new[] { ChainType.Main, ChainType.Test, ChainType.Regtest })
+            {
+                var btcNetwork = (chainType == ChainType.Main ? Network.Main :
+                                  chainType == ChainType.Regtest ? Network.RegTest :
+                                  chainType == ChainType.Test ? Network.TestNet : throw new NotSupportedException(chainType.ToString()));
+
+                var settings = new BTCPayDefaultSettings();
+                _Settings.Add(chainType, settings);
+                settings.ChainType = chainType;
+                settings.DefaultDataDirectory = StandardConfiguration.DefaultDataDirectory.GetDirectory("BTCPayServer", btcNetwork.Name);
+                settings.DefaultConfigurationFile = Path.Combine(settings.DefaultDataDirectory, "settings.config");
+                settings.DefaultPort = (chainType == ChainType.Main ? 23000 :
+                                                      chainType == ChainType.Regtest ? 23002 :
+                                                      chainType == ChainType.Test ? 23001 : throw new NotSupportedException(chainType.ToString()));
+            }
+        }
+
+        static Dictionary<ChainType, BTCPayDefaultSettings> _Settings;
+
+        public static BTCPayDefaultSettings GetDefaultSettings(ChainType chainType)
+        {
+            return _Settings[chainType];
+        }
+
+        public string DefaultDataDirectory { get; set; }
+        public string DefaultConfigurationFile { get; set; }
+        public ChainType ChainType { get; internal set; }
+        public int DefaultPort { get; set; }
+    }
     public class BTCPayNetwork
     {
         public Network NBitcoinNetwork { get; set; }
         public string CryptoCode { get; internal set; }
         public string BlockExplorerLink { get; internal set; }
         public string UriScheme { get; internal set; }
+        public IRateProvider DefaultRateProvider { get; set; }
+
+        [Obsolete("Should not be needed")]
+        public bool IsBTC
+        {
+            get
+            {
+                return CryptoCode == "BTC";
+            }
+        }
+
+        public string CryptoImagePath { get; set; }
+        public NBXplorer.NBXplorerNetwork NBXplorerNetwork { get; set; }
+
+
+        public BTCPayDefaultSettings DefaultSettings { get; set; }
+        public override string ToString()
+        {
+            return CryptoCode;
+        }
     }
 }

BTCPayServer/BTCPayNetworkProvider.Bitcoin.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+using NBitpayClient;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTC");
+            var coinaverage = new CoinAverageRateProvider("BTC");
+            var bitpay = new BitpayRateProvider(new Bitpay(new Key(), new Uri("https://bitpay.com/")));
+            var btcRate = new FallbackRateProvider(new IRateProvider[] { coinaverage, bitpay });
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                BlockExplorerLink = NBXplorerNetworkProvider.ChainType == ChainType.Main? "https://www.smartbit.com.au/tx/{0}" : "https://testnet.smartbit.com.au/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcoin",
+                DefaultRateProvider = btcRate,
+                CryptoImagePath = "imlegacy/bitcoin-symbol.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NBXplorerNetworkProvider.ChainType)
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Litecoin.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitLitecoin()
+        {
+            NBXplorer.Altcoins.Litecoin.Networks.EnsureRegistered();
+            var ltcRate = new CoinAverageRateProvider("LTC");
+
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("LTC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                BlockExplorerLink = NBXplorerNetworkProvider.ChainType == ChainType.Main ? "https://live.blockcypher.com/ltc/tx/{0}/" : "http://explorer.litecointools.com/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "litecoin",
+                DefaultRateProvider = ltcRate,
+                CryptoImagePath = "imlegacy/litecoin-symbol.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NBXplorerNetworkProvider.ChainType)
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.cs

@@ -1,47 +1,43 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using Microsoft.Extensions.Caching.Memory;
 using NBitcoin;
+using NBitpayClient;
+using NBXplorer;
 
 namespace BTCPayServer
 {
-    public class BTCPayNetworkProvider
+    public partial class BTCPayNetworkProvider
     {
         Dictionary<string, BTCPayNetwork> _Networks = new Dictionary<string, BTCPayNetwork>();
-        public BTCPayNetworkProvider(Network network)
+
+
+        private readonly NBXplorerNetworkProvider _NBXplorerNetworkProvider;
+        public NBXplorerNetworkProvider NBXplorerNetworkProvider
         {
-            if(network == Network.Main)
+            get
             {
-                Add(new BTCPayNetwork()
-                {
-                    CryptoCode = "BTC",
-                    BlockExplorerLink = "https://www.smartbit.com.au/tx/{0}",
-                    NBitcoinNetwork = Network.Main,
-                    UriScheme = "bitcoin"
-                });
+                return _NBXplorerNetworkProvider;
             }
+        }
 
-            if (network == Network.TestNet)
-            {
-                Add(new BTCPayNetwork()
-                {
-                    CryptoCode = "BTC",
-                    BlockExplorerLink = "https://testnet.smartbit.com.au/tx/{0}",
-                    NBitcoinNetwork = Network.TestNet,
-                    UriScheme = "bitcoin"
-                });
-            }
+        public BTCPayNetworkProvider(ChainType chainType)
+        {
+            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(chainType);
+            InitBitcoin();
+            InitLitecoin();
+        }
 
-            if (network == Network.RegTest)
+        [Obsolete("To use only for legacy stuff")]
+        public BTCPayNetwork BTC
+        {
+            get
             {
-                Add(new BTCPayNetwork()
-                {
-                    CryptoCode = "BTC",
-                    BlockExplorerLink = "https://testnet.smartbit.com.au/tx/{0}",
-                    NBitcoinNetwork = Network.RegTest,
-                    UriScheme = "bitcoin"
-                });
+                return GetNetwork("BTC");
             }
         }
 
@@ -50,6 +46,11 @@ namespace BTCPayServer
             _Networks.Add(network.CryptoCode, network);
         }
 
+        public IEnumerable<BTCPayNetwork> GetAll()
+        {
+            return _Networks.Values.ToArray();
+        }
+
         public BTCPayNetwork GetNetwork(string cryptoCode)
         {
             _Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetwork network);

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.0.50</Version>
+		<Version>1.0.1.18</Version>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />
@@ -21,22 +21,22 @@
     <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.50" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.13" />	  
+    <PackageReference Include="NBitcoin" Version="4.0.0.52" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.16" />	  
     <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.0.22" />
+    <PackageReference Include="NBXplorer.Client" Version="1.0.1.2" />
     <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" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.0.0" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.0.1" />
     <PackageReference Include="System.ValueTuple" Version="4.4.0" />
     <PackageReference Include="System.Xml.XmlSerializer" Version="4.0.11" />
   </ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.3" />
+		<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.5" />
 		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.1" PrivateAssets="All" />
-		<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.1" PrivateAssets="All" />
+		<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.2" PrivateAssets="All" />
 	</ItemGroup>
 
 	<ItemGroup>

BTCPayServer/CompositeDisposable.cs

@@ -1,19 +0,0 @@
-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

@@ -9,21 +9,20 @@ using System.Net;
 using System.Text;
 using StandardConfiguration;
 using Microsoft.Extensions.Configuration;
+using NBXplorer;
 
 namespace BTCPayServer.Configuration
 {
+    public class NBXplorerConnectionSetting
+    {
+        public string CryptoCode { get; internal set; }
+        public Uri ExplorerUri { get; internal set; }
+        public string CookieFile { get; internal set; }
+    }
+
     public class BTCPayServerOptions
     {
-        public Network Network
-        {
-            get; set;
-        }
-        public Uri Explorer
-        {
-            get; set;
-        }
-
-        public string CookieFile
+        public ChainType ChainType
         {
             get; set;
         }
@@ -43,22 +42,44 @@ namespace BTCPayServer.Configuration
             set;
         }
 
+        public List<NBXplorerConnectionSetting> NBXplorerConnectionSettings
+        {
+            get;
+            set;
+        } = new List<NBXplorerConnectionSetting>();
+
         public void LoadArgs(IConfiguration conf)
         {
-            var networkInfo = DefaultConfiguration.GetNetwork(conf);
-            Network = networkInfo?.Network;
-            if (Network == null)
-                throw new ConfigException("Invalid network");
+            ChainType = DefaultConfiguration.GetChainType(conf);
+            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(ChainType);
+            DataDir = conf.GetOrDefault<string>("datadir", defaultSettings.DefaultDataDirectory);
+            Logs.Configuration.LogInformation("Network: " + ChainType.ToString());
 
-            DataDir = conf.GetOrDefault<string>("datadir", networkInfo.DefaultDataDirectory);
-            Logs.Configuration.LogInformation("Network: " + Network);
+            var supportedChains = conf.GetOrDefault<string>("chains", "btc")
+                                      .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                                      .Select(t => t.ToUpperInvariant());
+            var validChains = new List<string>();
+            foreach (var net in new BTCPayNetworkProvider(ChainType).GetAll())
+            {
+                if (supportedChains.Contains(net.CryptoCode))
+                {
+                    validChains.Add(net.CryptoCode);
+                    NBXplorerConnectionSetting setting = new NBXplorerConnectionSetting();
+                    setting.CryptoCode = net.CryptoCode;
+                    setting.ExplorerUri = conf.GetOrDefault<Uri>($"{net.CryptoCode}.explorer.url", net.NBXplorerNetwork.DefaultSettings.DefaultUrl);
+                    setting.CookieFile = conf.GetOrDefault<string>($"{net.CryptoCode}.explorer.cookiefile", net.NBXplorerNetwork.DefaultSettings.DefaultCookieFile);
+                    NBXplorerConnectionSettings.Add(setting);
+                }
+            }
+            var invalidChains = String.Join(',', supportedChains.Where(s => !validChains.Contains(s)).ToArray());
+            if(!string.IsNullOrEmpty(invalidChains))
+                throw new ConfigException($"Invalid chains {invalidChains}");
 
-            Explorer = conf.GetOrDefault<Uri>("explorer.url", networkInfo.DefaultExplorerUrl);
-            CookieFile = conf.GetOrDefault<string>("explorer.cookiefile", networkInfo.DefaultExplorerCookieFile);
+            Logs.Configuration.LogInformation("Supported chains: " + String.Join(',', supportedChains.ToArray()));
             PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
             ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
-            InternalUrl = conf.GetOrDefault<Uri>("internalurl", null);
         }
+
         public string PostgresConnectionString
         {
             get;
@@ -69,6 +90,5 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
-        public Uri InternalUrl { get; private set; }
     }
 }

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -10,6 +10,7 @@ using System.Threading.Tasks;
 using NBitcoin;
 using System.Text;
 using CommandLine;
+using NBXplorer;
 
 namespace BTCPayServer.Configuration
 {
@@ -17,20 +18,26 @@ namespace BTCPayServer.Configuration
     {
         protected override CommandLineApplication CreateCommandLineApplicationCore()
         {
+            var provider = new BTCPayNetworkProvider(ChainType.Main);
+            var chains = string.Join(",", provider.GetAll().Select(n => n.CryptoCode.ToLowerInvariant()).ToArray());
             CommandLineApplication app = new CommandLineApplication(true)
             {
                 FullName = "BTCPay\r\nOpen source, self-hosted payment processor.",
                 Name = "BTCPay"
             };
             app.HelpOption("-? | -h | --help");
-            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("-n | --network", $"Set the network among (mainnet,testnet,regtest) (default: mainnet)", CommandOptionType.SingleValue);
+            app.Option("--testnet | -testnet", $"Use testnet (Deprecated, use --network instead)", CommandOptionType.BoolValue);
+            app.Option("--regtest | -regtest", $"Use regtest (Deprecated, use --network instead)", CommandOptionType.BoolValue);
+            app.Option("--chains | -c", $"Chains to support comma separated (default: btc, available: {chains})", CommandOptionType.SingleValue);
             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);
+            foreach (var network in provider.GetAll())
+            {
+                var crypto = network.CryptoCode.ToLowerInvariant();
+                app.Option($"--{crypto}explorerurl", $"Url of the NBxplorer for {network.CryptoCode} (default: {network.NBXplorerNetwork.DefaultSettings.DefaultUrl})", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}explorercookiefile", $"Path to the cookie file (default: {network.NBXplorerNetwork.DefaultSettings.DefaultCookieFile})", 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;
         }
 
@@ -38,54 +45,65 @@ namespace BTCPayServer.Configuration
 
         protected override string GetDefaultDataDir(IConfiguration conf)
         {
-            return GetNetwork(conf).DefaultDataDirectory;
+            return BTCPayDefaultSettings.GetDefaultSettings(GetChainType(conf)).DefaultDataDirectory;
         }
 
         protected override string GetDefaultConfigurationFile(IConfiguration conf)
         {
-            var network = GetNetwork(conf);
+            var network = BTCPayDefaultSettings.GetDefaultSettings(GetChainType(conf));
             var dataDir = conf["datadir"];
             if (dataDir == null)
                 return network.DefaultConfigurationFile;
             var fileName = Path.GetFileName(network.DefaultConfigurationFile);
-            return Path.Combine(dataDir, fileName);
+            var chainDir = Path.GetFileName(Path.GetDirectoryName(network.DefaultConfigurationFile));
+            chainDir = Path.Combine(dataDir, chainDir);
+            try
+            {
+                if (!Directory.Exists(chainDir))
+                    Directory.CreateDirectory(chainDir);
+            }
+            catch { }
+            return Path.Combine(chainDir, fileName);
         }
 
-        public static NetworkInformation GetNetwork(IConfiguration conf)
+        public static ChainType GetChainType(IConfiguration conf)
         {
             var network = conf.GetOrDefault<string>("network", null);
             if (network != null)
             {
-                var info = NetworkInformation.GetNetworkByName(network);
-                if (info == null)
-                    throw new ConfigException($"Invalid network name {network}");
-                return info;
+                var n = Network.GetNetwork(network);
+                if (n == null)
+                {
+                    throw new ConfigException($"Invalid network parameter '{network}'");
+                }
+                return n.ToChainType();
             }
+            var net = conf.GetOrDefault<bool>("regtest", false) ? ChainType.Regtest :
+                        conf.GetOrDefault<bool>("testnet", false) ? ChainType.Test : ChainType.Main;
 
-            var net = conf.GetOrDefault<bool>("regtest", false) ? Network.RegTest :
-                        conf.GetOrDefault<bool>("testnet", false) ? Network.TestNet : Network.Main;
-
-            return NetworkInformation.GetNetworkByName(net.Name);
+            return net;
         }
 
         protected override string GetDefaultConfigurationFileTemplate(IConfiguration conf)
         {
-            var network = GetNetwork(conf);
+            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(GetChainType(conf));
             StringBuilder builder = new StringBuilder();
             builder.AppendLine("### Global settings ###");
-            builder.AppendLine("#testnet=0");
-            builder.AppendLine("#regtest=0");
+            builder.AppendLine("#network=mainnet");
             builder.AppendLine();
             builder.AppendLine("### Server settings ###");
-            builder.AppendLine("#port=" + network.DefaultPort);
+            builder.AppendLine("#port=" + defaultSettings.DefaultPort);
             builder.AppendLine("#bind=127.0.0.1");
             builder.AppendLine();
             builder.AppendLine("### Database ###");
             builder.AppendLine("#postgres=User ID=root;Password=myPassword;Host=localhost;Port=5432;Database=myDataBase;");
             builder.AppendLine();
             builder.AppendLine("### NBXplorer settings ###");
-            builder.AppendLine("#explorer.url=" + network.DefaultExplorerUrl.AbsoluteUri);
-            builder.AppendLine("#explorer.cookiefile=" + network.DefaultExplorerCookieFile);
+            foreach (var n in new BTCPayNetworkProvider(defaultSettings.ChainType).GetAll())
+            {
+                builder.AppendLine($"#{n.CryptoCode}.explorer.url={n.NBXplorerNetwork.DefaultSettings.DefaultUrl}");
+                builder.AppendLine($"#{n.CryptoCode}.explorer.cookiefile={ n.NBXplorerNetwork.DefaultSettings.DefaultCookieFile}");
+            }
             return builder.ToString();
         }
 
@@ -93,7 +111,7 @@ namespace BTCPayServer.Configuration
 
         protected override IPEndPoint GetDefaultEndpoint(IConfiguration conf)
         {
-            return new IPEndPoint(IPAddress.Parse("127.0.0.1"), GetNetwork(conf).DefaultPort);
+            return new IPEndPoint(IPAddress.Parse("127.0.0.1"), BTCPayDefaultSettings.GetDefaultSettings(GetChainType(conf)).DefaultPort);
         }
     }
 }

BTCPayServer/Configuration/NetworkInformation.cs

@@ -1,103 +0,0 @@
-using Microsoft.Extensions.Configuration;
-using NBitcoin;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Configuration
-{
-    public class NetworkInformation
-    {
-        static NetworkInformation()
-        {
-            _Networks = new Dictionary<string, NetworkInformation>();
-            foreach (var network in Network.GetNetworks())
-            {
-                NetworkInformation info = new NetworkInformation();
-                info.DefaultDataDirectory = StandardConfiguration.DefaultDataDirectory.GetDirectory("BTCPayServer", network.Name);
-                info.DefaultConfigurationFile = Path.Combine(info.DefaultDataDirectory, "settings.config");
-                info.DefaultExplorerCookieFile = Path.Combine(StandardConfiguration.DefaultDataDirectory.GetDirectory("NBXplorer", network.Name, false), ".cookie");
-                info.Network = network;
-                info.DefaultExplorerUrl = new Uri("http://127.0.0.1:24446", UriKind.Absolute);
-                info.DefaultPort = 23002;
-                _Networks.Add(network.Name, info);
-                if (network == Network.Main)
-                {
-                    info.DefaultExplorerUrl = new Uri("http://127.0.0.1:24444", UriKind.Absolute);
-                    Main = info;
-                    info.DefaultPort = 23000;
-                }
-                if (network == Network.TestNet)
-                {
-                    info.DefaultExplorerUrl = new Uri("http://127.0.0.1:24445", UriKind.Absolute);
-                    info.DefaultPort = 23001;
-                }
-            }
-        }
-
-        static Dictionary<string, NetworkInformation> _Networks;
-        public static NetworkInformation GetNetworkByName(string name)
-        {
-            var value = _Networks.TryGet(name);
-            if (value != null)
-                return value;
-
-            //Maybe alias ?
-            var network = Network.GetNetwork(name);
-            if (network != null)
-            {
-                value = _Networks.TryGet(network.Name);
-                if (value != null)
-                    return value;
-            }
-            return null;
-        }
-
-        public static NetworkInformation Main
-        {
-            get;
-            set;
-        }
-        public Network Network
-        {
-            get; set;
-        }
-        public string DefaultConfigurationFile
-        {
-            get;
-            set;
-        }
-        public string DefaultDataDirectory
-        {
-            get;
-            set;
-        }
-        public Uri DefaultExplorerUrl
-        {
-            get;
-            internal set;
-        }
-        public int DefaultPort
-        {
-            get;
-            private set;
-        }
-        public string DefaultExplorerCookieFile
-        {
-            get;
-            internal set;
-        }
-
-        public override string ToString()
-        {
-            return Network.ToString();
-        }
-
-        public static string ToStringAll()
-        {
-            return string.Join(", ", _Networks.Select(n => n.Key).ToArray());
-        }
-    }
-}

BTCPayServer/Controllers/AccountController.cs

@@ -15,6 +15,7 @@ using BTCPayServer.Models.AccountViewModels;
 using BTCPayServer.Services;
 using BTCPayServer.Services.Mails;
 using BTCPayServer.Services.Stores;
+using BTCPayServer.Logging;
 
 namespace BTCPayServer.Controllers
 {
@@ -25,10 +26,10 @@ namespace BTCPayServer.Controllers
         private readonly UserManager<ApplicationUser> _userManager;
         private readonly SignInManager<ApplicationUser> _signInManager;
         private readonly IEmailSender _emailSender;
-        private readonly ILogger _logger;
         StoreRepository storeRepository;
         RoleManager<IdentityRole> _RoleManager;
         SettingsRepository _SettingsRepository;
+        ILogger _logger;
 
         public AccountController(
             UserManager<ApplicationUser> userManager,
@@ -36,16 +37,15 @@ namespace BTCPayServer.Controllers
             StoreRepository storeRepository,
             SignInManager<ApplicationUser> signInManager,
             IEmailSender emailSender,
-            SettingsRepository settingsRepository,
-            ILogger<AccountController> logger)
+            SettingsRepository settingsRepository)
         {
             this.storeRepository = storeRepository;
             _userManager = userManager;
             _signInManager = signInManager;
             _emailSender = emailSender;
-            _logger = logger;
             _RoleManager = roleManager;
             _SettingsRepository = settingsRepository;
+            _logger = Logs.PayServer;
         }
 
         [TempData]
@@ -259,12 +259,10 @@ namespace BTCPayServer.Controllers
                 var result = await _userManager.CreateAsync(user, model.Password);
                 if (result.Succeeded)
                 {
-                    _logger.LogInformation("User created a new account with password.");
-
                     var admin = await _userManager.GetUsersInRoleAsync(Roles.ServerAdmin);
+                    Logs.PayServer.LogInformation($"A new user just registered {user.Email} {(admin.Count == 0 ? "(admin)" : "")}");
                     if (admin.Count == 0)
                     {
-                        _logger.LogInformation("Admin created.");
                         await _RoleManager.CreateAsync(new IdentityRole(Roles.ServerAdmin));
                         await _userManager.AddToRoleAsync(user, Roles.ServerAdmin);
                     }
@@ -273,7 +271,6 @@ namespace BTCPayServer.Controllers
                     var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
                     RegisteredUserId = user.Id;
                     await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
-                    _logger.LogInformation("User created a new account with password.");
                     if (!policies.RequiresConfirmedEmail)
                     {
                         await _signInManager.SignInAsync(user, isPersistent: false);
@@ -292,7 +289,7 @@ namespace BTCPayServer.Controllers
             return View(model);
         }
 
-        /// <summary>
+        /// <summary> 
         /// Test property
         /// </summary>
         public string RegisteredUserId

BTCPayServer/Controllers/CallbackController.cs

@@ -1,143 +0,0 @@
-using BTCPayServer.Logging;
-using BTCPayServer.Services.Invoices;
-using BTCPayServer.Services;
-using BTCPayServer.Services.Wallets;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-using NBitcoin;
-using NBXplorer;
-using Microsoft.Extensions.Logging;
-using NBXplorer.DerivationStrategy;
-using NBXplorer.Models;
-using System;
-using System.Collections.Generic;
-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
-{
-    public class CallbackController : Controller
-    {
-        public class CallbackSettings
-        {
-            public string Token
-            {
-                get; set;
-            }
-        }
-        SettingsRepository _Settings;
-        Network _Network;
-        ExplorerClient _Explorer;
-        BTCPayServerOptions _Options;
-        EventAggregator _EventAggregator;
-        IServer _Server;
-        public CallbackController(SettingsRepository repo,
-                                  ExplorerClient explorer,
-                                  EventAggregator eventAggregator,
-                                  BTCPayServerOptions options,
-                                  IServer server,
-                                  BTCPayNetworkProvider networkProvider)
-        {
-            _Settings = repo;
-            _Network = networkProvider.GetNetwork("BTC").NBitcoinNetwork;
-            _Explorer = explorer;
-            _Options = options;
-            _EventAggregator = eventAggregator;
-            _Server = server;
-        }
-
-        [Route("callbacks/transactions")]
-        [HttpPost]
-        public async Task NewTransaction(string token)
-        {
-            await AssertToken(token);
-            //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();
-            var match = serializer.ToObject<TransactionMatch>(content);
-
-            foreach (var output in match.Outputs)
-            {
-                var evt = new TxOutReceivedEvent();
-                evt.ScriptPubKey = output.ScriptPubKey;
-                evt.Address = output.ScriptPubKey.GetDestinationAddress(_Network);
-                _EventAggregator.Publish(evt);
-            }
-        }
-
-        [Route("callbacks/blocks")]
-        [HttpPost]
-        public async Task NewBlock(string token)
-        {
-            await AssertToken(token);
-            _EventAggregator.Publish(new Events.NewBlockEvent());
-        }
-
-        private async Task AssertToken(string token)
-        {
-            var callback = await _Settings.GetSettingAsync<CallbackSettings>();
-            if (await GetToken() != token)
-                throw new BTCPayServer.BitpayHttpException(400, "invalid-callback-token");
-        }
-
-        public async Task<Uri> GetCallbackUriAsync()
-        {
-            string token = await GetToken();
-            return BuildCallbackUri("callbacks/transactions?token=" + token);
-        }
-
-        public async Task RegisterCallbackUriAsync(DerivationStrategyBase derivationScheme)
-        {
-            var uri = await GetCallbackUriAsync();
-            await _Explorer.SubscribeToWalletAsync(uri, derivationScheme);
-        }
-
-        private async Task<string> GetToken()
-        {
-            var callback = await _Settings.GetSettingAsync<CallbackSettings>();
-            if (callback == null)
-            {
-                callback = new CallbackSettings() { Token = Guid.NewGuid().ToString() };
-                await _Settings.UpdateSetting(callback);
-            }
-            var token = callback.Token;
-            return token;
-        }
-
-        public async Task<Uri> GetCallbackBlockUriAsync()
-        {
-            string token = await GetToken();
-            return BuildCallbackUri("callbacks/blocks?token=" + token);
-        }
-
-        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)
-        {
-            await _Explorer.SubscribeToBlocksAsync(uri);
-            return uri;
-        }
-    }
-}

BTCPayServer/Controllers/InvoiceController.PaymentProtocol.cs

@@ -61,15 +61,23 @@ namespace BTCPayServer.Controllers
 
         [HttpPost]
         [Route("i/{invoiceId}", Order = 99)]
+        [Route("i/{invoiceId}/{cryptoCode}", Order = 99)]
         [MediaTypeConstraint("application/bitcoin-payment")]
-        public async Task<IActionResult> PostPayment(string invoiceId)
+        public async Task<IActionResult> PostPayment(string invoiceId, string cryptoCode = null)
         {
             var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
-            if (invoice == null || invoice.IsExpired())
+            if (cryptoCode == null)
+                cryptoCode = "BTC";
+            var network = _NetworkProvider.GetNetwork(cryptoCode);
+            if (network == null || invoice == null || invoice.IsExpired() || !invoice.Support(network))
+                return NotFound();
+
+            var wallet = _WalletProvider.GetWallet(network);
+            if (wallet == null)
                 return NotFound();
             var payment = PaymentMessage.Load(Request.Body);
-            var unused = _Wallet.BroadcastTransactionsAsync(payment.Transactions);
-            await _InvoiceRepository.AddRefundsAsync(invoiceId, payment.RefundTo.Select(p => new TxOut(p.Amount, p.Script)).ToArray());
+            var unused = wallet.BroadcastTransactionsAsync(payment.Transactions);
+            await _InvoiceRepository.AddRefundsAsync(invoiceId, payment.RefundTo.Select(p => new TxOut(p.Amount, p.Script)).ToArray(), network.NBitcoinNetwork);
             return new PaymentAckActionResult(payment.CreateACK(invoiceId + " is currently processing, thanks for your purchase..."));
         }
     }

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -19,88 +19,83 @@ using BTCPayServer.Services.Rates;
 using System.Net.WebSockets;
 using System.Threading;
 using BTCPayServer.Events;
+using NBXplorer;
 
 namespace BTCPayServer.Controllers
 {
     public partial class InvoiceController
     {
-        [HttpPost]
-        [Route("invoices/{invoiceId}")]
-        public IActionResult Invoice(string invoiceId, string command, string cryptoCode = null)
-        {
-            if (command == "refresh")
-            {
-                _Watcher.Watch(invoiceId);
-            }
-            StatusMessage = "Invoice is state is being refreshed, please refresh the page soon...";
-            return RedirectToAction(nameof(Invoice), new
-            {
-                invoiceId = invoiceId
-            });
-        }
-
         [HttpGet]
         [Route("invoices/{invoiceId}")]
-        public async Task<IActionResult> Invoice(string invoiceId, string cryptoCode = null)
+        public async Task<IActionResult> Invoice(string invoiceId)
         {
-            if (cryptoCode == null)
-                cryptoCode = "BTC";
             var invoice = (await _InvoiceRepository.GetInvoices(new InvoiceQuery()
             {
                 UserId = GetUserId(),
-                InvoiceId = invoiceId
+                InvoiceId = invoiceId,
+                IncludeAddresses = true,
+                IncludeEvents = true
             })).FirstOrDefault();
             if (invoice == null)
                 return NotFound();
 
-            var network = _NetworkProvider.GetNetwork(cryptoCode);
-            if (network == null || !invoice.Support(network))
-                return NotFound();
-
-            var cryptoData = invoice.GetCryptoData(network);
-
             var dto = invoice.EntityToDTO(_NetworkProvider);
-            var cryptoInfo = dto.CryptoInfo.First(o => o.CryptoCode.Equals(cryptoCode, StringComparison.OrdinalIgnoreCase));
             var store = await _StoreRepository.FindStore(invoice.StoreId);
 
-            var accounting = cryptoData.Calculate();
             InvoiceDetailsModel model = new InvoiceDetailsModel()
             {
                 StoreName = store.StoreName,
                 StoreLink = Url.Action(nameof(StoresController.UpdateStore), "Stores", new { storeId = store.Id }),
                 Id = invoice.Id,
                 Status = invoice.Status,
+                TransactionSpeed = invoice.SpeedPolicy == SpeedPolicy.HighSpeed ? "high" : invoice.SpeedPolicy == SpeedPolicy.MediumSpeed ? "medium" : "low",
                 RefundEmail = invoice.RefundMail,
                 CreatedDate = invoice.InvoiceTime,
                 ExpirationDate = invoice.ExpirationTime,
+                MonitoringDate = invoice.MonitoringExpiration,
                 OrderId = invoice.OrderId,
                 BuyerInformation = invoice.BuyerInformation,
-                Rate = cryptoData.Rate,
-                Fiat = dto.Price + " " + dto.Currency,
-                BTC = accounting.TotalDue.ToString() + $" {network.CryptoCode}",
-                BTCDue = accounting.Due.ToString() + $" {network.CryptoCode}",
-                BTCPaid = accounting.Paid.ToString() + $" {network.CryptoCode}",
-                NetworkFee = accounting.NetworkFee.ToString() + $" {network.CryptoCode}",
+                Fiat = FormatCurrency((decimal)dto.Price, dto.Currency),
                 NotificationUrl = invoice.NotificationURL,
+                RedirectUrl = invoice.RedirectURL,
                 ProductInformation = invoice.ProductInformation,
-                BitcoinAddress = BitcoinAddress.Create(cryptoInfo.Address, network.NBitcoinNetwork),
-                PaymentUrl = cryptoInfo.PaymentUrls.BIP72
+                StatusException = invoice.ExceptionStatus,
+                Events = invoice.Events
             };
 
+            foreach (var data in invoice.GetCryptoData(null))
+            {
+                var cryptoInfo = dto.CryptoInfo.First(o => o.CryptoCode.Equals(data.Key, StringComparison.OrdinalIgnoreCase));
+                var accounting = data.Value.Calculate();
+                var paymentNetwork = _NetworkProvider.GetNetwork(data.Key);
+                var cryptoPayment = new InvoiceDetailsModel.CryptoPayment();
+                cryptoPayment.CryptoCode = paymentNetwork.CryptoCode;
+                cryptoPayment.Due = accounting.Due.ToString() + $" {paymentNetwork.CryptoCode}";
+                cryptoPayment.Paid = accounting.CryptoPaid.ToString() + $" {paymentNetwork.CryptoCode}";
+                cryptoPayment.Address = data.Value.DepositAddress.ToString();
+                cryptoPayment.Rate = FormatCurrency(data.Value);
+                cryptoPayment.PaymentUrl = cryptoInfo.PaymentUrls.BIP21;
+                model.CryptoPayments.Add(cryptoPayment);
+            }
+
             var payments = invoice
-                .Payments
+                .GetPayments()
                 .Select(async payment =>
                 {
                     var m = new InvoiceDetailsModel.Payment();
-                    m.DepositAddress = payment.GetScriptPubKey().GetDestinationAddress(network.NBitcoinNetwork);
-                    m.Confirmations = (await _Explorer.GetTransactionAsync(payment.Outpoint.Hash))?.Confirmations ?? 0;
+                    var paymentNetwork = _NetworkProvider.GetNetwork(payment.GetCryptoCode());
+                    m.CryptoCode = payment.GetCryptoCode();
+                    m.DepositAddress = payment.GetScriptPubKey().GetDestinationAddress(paymentNetwork.NBitcoinNetwork);
+                    m.Confirmations = (await _ExplorerClients.GetExplorerClient(payment.GetCryptoCode())?.GetTransactionAsync(payment.Outpoint.Hash))?.Confirmations ?? 0;
                     m.TransactionId = payment.Outpoint.Hash.ToString();
                     m.ReceivedTime = payment.ReceivedTime;
-                    m.TransactionLink = string.Format(network.BlockExplorerLink, m.TransactionId);
+                    m.TransactionLink = string.Format(paymentNetwork.BlockExplorerLink, m.TransactionId);
+                    m.Replaced = !payment.Accounted;
                     return m;
                 })
                 .ToArray();
             await Task.WhenAll(payments);
+            model.Addresses = invoice.HistoricalAddresses;
             model.Payments = payments.Select(p => p.GetAwaiter().GetResult()).ToList();
             model.StatusMessage = StatusMessage;
             return View(model);
@@ -108,13 +103,12 @@ namespace BTCPayServer.Controllers
 
         [HttpGet]
         [Route("i/{invoiceId}")]
+        [Route("i/{invoiceId}/{cryptoCode}")]
         [Route("invoice")]
         [AcceptMediaTypeConstraint("application/bitcoin-paymentrequest", false)]
         [XFrameOptionsAttribute(null)]
         public async Task<IActionResult> Checkout(string invoiceId, string id = null, string cryptoCode = null)
         {
-            if (cryptoCode == null)
-                cryptoCode = "BTC";
             //Keep compatibility with Bitpay
             invoiceId = invoiceId ?? id;
             id = invoiceId;
@@ -129,47 +123,86 @@ namespace BTCPayServer.Controllers
 
         private async Task<PaymentModel> GetInvoiceModel(string invoiceId, string cryptoCode)
         {
-            if (cryptoCode == null)
-                throw new ArgumentNullException(nameof(cryptoCode));
             var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            if (invoice == null)
+                return null;
+            var store = await _StoreRepository.FindStore(invoice.StoreId);
+            bool isDefaultCrypto = false;
+            if (cryptoCode == null)
+            { 
+                cryptoCode = store.GetDefaultCrypto();
+                isDefaultCrypto = true;
+            }
             var network = _NetworkProvider.GetNetwork(cryptoCode);
-            if (invoice == null || network == null || !invoice.Support(network))
+            if (invoice == null || network == null)
                 return null;
 
-            var cryptoData = invoice.GetCryptoData(network);
-            var store = await _StoreRepository.FindStore(invoice.StoreId);
+            if(!invoice.Support(network))
+            {
+                if(!isDefaultCrypto)
+                    return null;
+                network = invoice.GetCryptoData(_NetworkProvider).First().Value.Network;
+            }
+            var cryptoData = invoice.GetCryptoData(network, _NetworkProvider);
+
             var dto = invoice.EntityToDTO(_NetworkProvider);
             var cryptoInfo = dto.CryptoInfo.First(o => o.CryptoCode == network.CryptoCode);
+
             var currency = invoice.ProductInformation.Currency;
             var accounting = cryptoData.Calculate();
             var model = new PaymentModel()
             {
+                CryptoCode = network.CryptoCode,
                 ServerUrl = HttpContext.Request.GetAbsoluteRoot(),
                 OrderId = invoice.OrderId,
                 InvoiceId = invoice.Id,
                 BtcAddress = cryptoData.DepositAddress,
-                BtcAmount = (accounting.TotalDue - cryptoData.TxFee).ToString(),
-                BtcTotalDue = accounting.TotalDue.ToString(),
+                OrderAmount = (accounting.TotalDue - accounting.NetworkFee).ToString(),
                 BtcDue = accounting.Due.ToString(),
                 CustomerEmail = invoice.RefundMail,
                 ExpirationSeconds = Math.Max(0, (int)(invoice.ExpirationTime - DateTimeOffset.UtcNow).TotalSeconds),
                 MaxTimeSeconds = (int)(invoice.ExpirationTime - invoice.InvoiceTime).TotalSeconds,
+                MaxTimeMinutes = (int)(invoice.ExpirationTime - invoice.InvoiceTime).TotalMinutes,
                 ItemDesc = invoice.ProductInformation.ItemDesc,
-                Rate = cryptoData.Rate.ToString("C", _CurrencyNameTable.GetCurrencyProvider(currency)) + $" ({currency})",
+                Rate = FormatCurrency(cryptoData),
                 MerchantRefLink = invoice.RedirectURL ?? "/",
                 StoreName = store.StoreName,
-                TxFees = cryptoData.TxFee.ToString(),
-                InvoiceBitcoinUrl = cryptoInfo.PaymentUrls.BIP72,
+                InvoiceBitcoinUrl = cryptoInfo.PaymentUrls.BIP21,
                 TxCount = accounting.TxCount,
                 BtcPaid = accounting.Paid.ToString(),
-                Status = invoice.Status
+                Status = invoice.Status,
+                CryptoImage = "/" + Url.Content(network.CryptoImagePath),
+                NetworkFeeDescription = $"{accounting.TxCount} transaction{(accounting.TxCount > 1 ? "s" : "")} x {cryptoData.TxFee} {network.CryptoCode}",
+                AvailableCryptos = invoice.GetCryptoData(_NetworkProvider)
+                                          .Where(i => i.Value.Network != null)
+                                          .Select(kv=> new PaymentModel.AvailableCrypto()
+                                            {
+                                                CryptoCode = kv.Key,
+                                                CryptoImage = "/" + kv.Value.Network.CryptoImagePath,
+                                                Link = Url.Action(nameof(Checkout), new { invoiceId = invoiceId, cryptoCode = kv.Key })
+                                            }).Where(c => c.CryptoImage != "/")
+                .ToList()
             };
 
+            var isMultiCurrency = invoice.GetPayments().Select(p=>p.GetCryptoCode()).Concat(new[] { network.CryptoCode }).Distinct().Count() > 1;
+            if (isMultiCurrency)
+                model.NetworkFeeDescription = $"{accounting.NetworkFee} {network.CryptoCode}";
+
             var expiration = TimeSpan.FromSeconds(model.ExpirationSeconds);
             model.TimeLeft = PrettyPrint(expiration);
             return model;
         }
 
+        private string FormatCurrency(CryptoData cryptoData)
+        {
+            string currency = cryptoData.ParentEntity.ProductInformation.Currency;
+            return FormatCurrency(cryptoData.Rate, currency);
+        }
+        public string FormatCurrency(decimal price, string currency)
+        {
+            return price.ToString("C", _CurrencyNameTable.GetCurrencyProvider(currency)) + $" ({currency})";
+        }
+
         private string PrettyPrint(TimeSpan expiration)
         {
             StringBuilder builder = new StringBuilder();
@@ -183,10 +216,9 @@ namespace BTCPayServer.Controllers
 
         [HttpGet]
         [Route("i/{invoiceId}/status")]
+        [Route("i/{invoiceId}/{cryptoCode}/status")]
         public async Task<IActionResult> GetStatus(string invoiceId, string cryptoCode)
         {
-            if (cryptoCode == null)
-                cryptoCode = "BTC";
             var model = await GetInvoiceModel(invoiceId, cryptoCode);
             if (model == null)
                 return NotFound();
@@ -206,9 +238,8 @@ namespace BTCPayServer.Controllers
             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));
+                leases.Add(_EventAggregator.Subscribe<Events.InvoiceDataChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
+                leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
                 while (true)
                 {
                     var message = await webSocket.ReceiveAsync(DummyBuffer, default(CancellationToken));
@@ -223,7 +254,7 @@ namespace BTCPayServer.Controllers
             }
             return new EmptyResult();
         }
-        
+
         ArraySegment<Byte> DummyBuffer = new ArraySegment<Byte>(new Byte[1]);
         private async Task NotifySocket(WebSocket webSocket, string invoiceId, string expectedId)
         {
@@ -235,7 +266,7 @@ namespace BTCPayServer.Controllers
             {
                 await webSocket.SendAsync(DummyBuffer, WebSocketMessageType.Binary, true, cts.Token);
             }
-            catch { await CloseSocket(webSocket); }
+            catch { try { webSocket.Dispose(); } catch { } }
         }
 
         private static async Task CloseSocket(WebSocket webSocket)
@@ -250,7 +281,7 @@ namespace BTCPayServer.Controllers
                 }
             }
             catch { }
-            finally { webSocket.Dispose(); }
+            finally { try { webSocket.Dispose(); } catch { } }
         }
 
         [HttpPost]
@@ -325,7 +356,7 @@ namespace BTCPayServer.Controllers
                 return View(model);
             }
             var store = await _StoreRepository.FindStore(model.StoreId, GetUserId());
-            if (string.IsNullOrEmpty(store.DerivationStrategy))
+            if (store.GetDerivationStrategies(_NetworkProvider).Count() == 0)
             {
                 StatusMessage = "Error: You need to configure the derivation scheme in order to create an invoice";
                 return RedirectToAction(nameof(StoresController.UpdateStore), "Stores", new
@@ -384,6 +415,7 @@ namespace BTCPayServer.Controllers
         public async Task<IActionResult> InvalidatePaidInvoice(string invoiceId)
         {
             await _InvoiceRepository.UpdatePaidInvoiceToInvalid(invoiceId);
+            _EventAggregator.Publish(new InvoiceEvent(invoiceId, 1008, "invoice_markedInvalid"));
             return RedirectToAction(nameof(ListInvoices));
         }
 

BTCPayServer/Controllers/InvoiceController.cs

@@ -38,41 +38,39 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.AspNetCore.Mvc.Routing;
 using NBXplorer.DerivationStrategy;
 using NBXplorer;
+using BTCPayServer.HostedServices;
 
 namespace BTCPayServer.Controllers
 {
     public partial class InvoiceController : Controller
     {
         InvoiceRepository _InvoiceRepository;
-        BTCPayWallet _Wallet;
-        IRateProvider _RateProvider;
-        private InvoiceWatcher _Watcher;
+        BTCPayWalletProvider _WalletProvider;
+        IRateProviderFactory _RateProviders;
         StoreRepository _StoreRepository;
         UserManager<ApplicationUser> _UserManager;
         IFeeProviderFactory _FeeProviderFactory;
         private CurrencyNameTable _CurrencyNameTable;
-        ExplorerClient _Explorer;
         EventAggregator _EventAggregator;
         BTCPayNetworkProvider _NetworkProvider;
+        ExplorerClientProvider _ExplorerClients;
         public InvoiceController(InvoiceRepository invoiceRepository,
             CurrencyNameTable currencyNameTable,
             UserManager<ApplicationUser> userManager,
-            BTCPayWallet wallet,
-            IRateProvider rateProvider,
+            BTCPayWalletProvider walletProvider,
+            IRateProviderFactory rateProviders,
             StoreRepository storeRepository,
             EventAggregator eventAggregator,
-            InvoiceWatcherAccessor watcher,
-            ExplorerClient explorerClient,
             BTCPayNetworkProvider networkProvider,
+            ExplorerClientProvider explorerClientProviders,
             IFeeProviderFactory feeProviderFactory)
         {
+            _ExplorerClients = explorerClientProviders;
             _CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
-            _Explorer = explorerClient ?? throw new ArgumentNullException(nameof(explorerClient));
             _StoreRepository = storeRepository ?? throw new ArgumentNullException(nameof(storeRepository));
             _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))).Instance;
+            _WalletProvider = walletProvider ?? throw new ArgumentNullException(nameof(walletProvider));
+            _RateProviders = rateProviders ?? throw new ArgumentNullException(nameof(rateProviders));
             _UserManager = userManager;
             _FeeProviderFactory = feeProviderFactory ?? throw new ArgumentNullException(nameof(feeProviderFactory));
             _EventAggregator = eventAggregator;
@@ -80,24 +78,28 @@ namespace BTCPayServer.Controllers
         }
 
 
-        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl, double expiryMinutes = 15)
+        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl)
         {
-            var derivationStrategy = store.DerivationStrategy;
+            var derivationStrategies = store.GetDerivationStrategies(_NetworkProvider).Where(c => _ExplorerClients.IsAvailable(c.Network.CryptoCode)).ToList();
+            if (derivationStrategies.Count == 0)
+                throw new BitpayHttpException(400, "No derivation strategy are available now for this store");
             var entity = new InvoiceEntity
             {
-                InvoiceTime = DateTimeOffset.UtcNow,
-                DerivationStrategy = derivationStrategy ?? throw new BitpayHttpException(400, "This store has not configured the derivation strategy")
+                InvoiceTime = DateTimeOffset.UtcNow
             };
+            entity.SetDerivationStrategies(derivationStrategies);
+
             var storeBlob = store.GetStoreBlob();
             Uri notificationUri = Uri.IsWellFormedUriString(invoice.NotificationURL, UriKind.Absolute) ? new Uri(invoice.NotificationURL, UriKind.Absolute) : null;
             if (notificationUri == null || (notificationUri.Scheme != "http" && notificationUri.Scheme != "https")) //TODO: Filer non routable addresses ?
                 notificationUri = null;
             EmailAddressAttribute emailValidator = new EmailAddressAttribute();
-            entity.ExpirationTime = entity.InvoiceTime.AddMinutes(expiryMinutes);
+            entity.ExpirationTime = entity.InvoiceTime.AddMinutes(storeBlob.InvoiceExpiration);
             entity.MonitoringExpiration = entity.ExpirationTime + TimeSpan.FromMinutes(storeBlob.MonitoringExpiration);
             entity.OrderId = invoice.OrderId;
             entity.ServerUrl = serverUrl;
-            entity.FullNotifications = invoice.FullNotifications;
+            entity.FullNotifications = invoice.FullNotifications || invoice.ExtendedNotifications;
+            entity.ExtendedNotifications = invoice.ExtendedNotifications;
             entity.NotificationURL = notificationUri?.AbsoluteUri;
             entity.BuyerInformation = Map<Invoice, BuyerInformation>(invoice);
             //Another way of passing buyer info to support
@@ -113,33 +115,41 @@ namespace BTCPayServer.Controllers
             entity.Status = "new";
             entity.SpeedPolicy = ParseSpeedPolicy(invoice.TransactionSpeed, store.SpeedPolicy);
 
-            var queries = storeBlob.GetSupportedCryptoCurrencies()
-                    .Select(n => _NetworkProvider.GetNetwork(n))
-                    .Where(n => n != null)
-                    .Select(network =>
+            var queries = derivationStrategies
+                    .Select(derivationStrategy => (Wallet: _WalletProvider.GetWallet(derivationStrategy.Network),
+                                                    DerivationStrategy: derivationStrategy.DerivationStrategyBase,
+                                                    Network: derivationStrategy.Network,
+                                                    RateProvider: _RateProviders.GetRateProvider(derivationStrategy.Network),
+                                                    FeeRateProvider: _FeeProviderFactory.CreateFeeProvider(derivationStrategy.Network)))
+                    .Where(_ => _.Wallet != null &&
+                                _.FeeRateProvider != null &&
+                                _.RateProvider != null)
+                    .Select(_ =>
                     {
                         return new
                         {
-                            network = network,
-                            getFeeRate = _FeeProviderFactory.CreateFeeProvider(network).GetFeeRateAsync(),
-                            getRate = _RateProvider.GetRateAsync(invoice.Currency),
-                            getAddress = _Wallet.ReserveAddressAsync(ParseDerivationStrategy(derivationStrategy, network))
+                            network = _.Network,
+                            getFeeRate = _.FeeRateProvider.GetFeeRateAsync(),
+                            getRate = storeBlob.ApplyRateRules(_.Network, _.RateProvider).GetRateAsync(invoice.Currency),
+                            getAddress = _.Wallet.ReserveAddressAsync(_.DerivationStrategy)
                         };
                     });
 
+            bool legacyBTCisSet = false;
             var cryptoDatas = new Dictionary<string, CryptoData>();
             foreach (var q in queries)
             {
                 CryptoData cryptoData = new CryptoData();
                 cryptoData.CryptoCode = q.network.CryptoCode;
                 cryptoData.FeeRate = (await q.getFeeRate);
-                cryptoData.TxFee = storeBlob.NetworkFeeDisabled ? Money.Zero : cryptoData.FeeRate.GetFee(100); // assume price for 100 bytes
+                cryptoData.TxFee = GetTxFee(storeBlob, cryptoData.FeeRate); // assume price for 100 bytes
                 cryptoData.Rate = await q.getRate;
                 cryptoData.DepositAddress = (await q.getAddress).ToString();
 
 #pragma warning disable CS0618
-                if (q.network.CryptoCode == "BTC")
+                if (q.network.IsBTC)
                 {
+                    legacyBTCisSet = true;
                     entity.TxFee = cryptoData.TxFee;
                     entity.Rate = cryptoData.Rate;
                     entity.DepositAddress = cryptoData.DepositAddress;
@@ -147,14 +157,37 @@ namespace BTCPayServer.Controllers
 #pragma warning restore CS0618
                 cryptoDatas.Add(cryptoData.CryptoCode, cryptoData);
             }
+
+            if (!legacyBTCisSet)
+            {
+                // Legacy Bitpay clients expect information for BTC information, even if the store do not support it
+#pragma warning disable CS0618
+                var btc = _NetworkProvider.BTC;
+                var feeProvider = _FeeProviderFactory.CreateFeeProvider(btc);
+                var rateProvider = storeBlob.ApplyRateRules(btc, _RateProviders.GetRateProvider(btc));
+                if (feeProvider != null && rateProvider != null)
+                {
+                    var gettingFee = feeProvider.GetFeeRateAsync();
+                    var gettingRate = rateProvider.GetRateAsync(invoice.Currency);
+                    entity.TxFee = GetTxFee(storeBlob, await gettingFee);
+                    entity.Rate = await gettingRate;
+                }
+#pragma warning restore CS0618
+            }
+
             entity.SetCryptoData(cryptoDatas);
             entity.PosData = invoice.PosData;
             entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, _NetworkProvider);
-            _Watcher.Watch(entity.Id);
+            _EventAggregator.Publish(new Events.InvoiceEvent(entity, 1001, "invoice_created"));
             var resp = entity.EntityToDTO(_NetworkProvider);
             return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
         }
 
+        private static Money GetTxFee(StoreBlob storeBlob, FeeRate feeRate)
+        {
+            return storeBlob.NetworkFeeDisabled ? Money.Zero : feeRate.GetFee(100);
+        }
+
         private SpeedPolicy ParseSpeedPolicy(string transactionSpeed, SpeedPolicy defaultPolicy)
         {
             if (transactionSpeed == null)

BTCPayServer/Controllers/ManageController.cs

@@ -33,7 +33,6 @@ namespace BTCPayServer.Controllers
         private readonly ILogger _logger;
         private readonly UrlEncoder _urlEncoder;
         TokenRepository _TokenRepository;
-        private readonly BTCPayWallet _Wallet;
         IHostingEnvironment _Env;
         StoreRepository _StoreRepository;
 
@@ -47,7 +46,7 @@ namespace BTCPayServer.Controllers
           ILogger<ManageController> logger,
           UrlEncoder urlEncoder,
           TokenRepository tokenRepository,
-          BTCPayWallet wallet,
+          BTCPayWalletProvider walletProvider,
           StoreRepository storeRepository,
           IHostingEnvironment env)
         {
@@ -57,7 +56,6 @@ namespace BTCPayServer.Controllers
             _logger = logger;
             _urlEncoder = urlEncoder;
             _TokenRepository = tokenRepository;
-            _Wallet = wallet;
             _Env = env;
             _StoreRepository = storeRepository;
         }

BTCPayServer/Controllers/RateController.cs

@@ -7,34 +7,68 @@ using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Filters;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
 
 namespace BTCPayServer.Controllers
 {
     public class RateController : Controller
     {
-        IRateProvider _RateProvider;
+        IRateProviderFactory _RateProviderFactory;
+        BTCPayNetworkProvider _NetworkProvider;
         CurrencyNameTable _CurrencyNameTable;
-        public RateController(IRateProvider rateProvider, CurrencyNameTable currencyNameTable)
+        StoreRepository _StoreRepo;
+        public RateController(
+            IRateProviderFactory rateProviderFactory, 
+            BTCPayNetworkProvider networkProvider,
+            StoreRepository storeRepo,
+            CurrencyNameTable currencyNameTable)
         {
-            _RateProvider = rateProvider ?? throw new ArgumentNullException(nameof(rateProvider));
+            _RateProviderFactory = rateProviderFactory ?? throw new ArgumentNullException(nameof(rateProviderFactory));
+            _NetworkProvider = networkProvider;
+            _StoreRepo = storeRepo;
             _CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
         }
 
         [Route("rates")]
         [HttpGet]
         [BitpayAPIConstraint]
-        public async Task<DataWrapper<NBitpayClient.Rate[]>> GetRates()
+        public async Task<IActionResult> GetRates(string cryptoCode = null, string storeId = null)
         {
-            var allRates = (await _RateProvider.GetRatesAsync());
-            return new DataWrapper<NBitpayClient.Rate[]>
-                    (allRates.Select(r =>
+            var result = await GetRates2(cryptoCode, storeId);
+            var rates = (result as JsonResult)?.Value as NBitpayClient.Rate[];
+            if(rates == null)
+                return result;
+            return Json(new DataWrapper<NBitpayClient.Rate[]>(rates)); 
+        }
+
+        [Route("api/rates")]
+        [HttpGet]
+        public async Task<IActionResult> GetRates2(string cryptoCode = null, string storeId = null)
+        {
+            cryptoCode = cryptoCode ?? "BTC";
+            var network = _NetworkProvider.GetNetwork(cryptoCode);
+            if (network == null)
+                return NotFound();
+            var rateProvider = _RateProviderFactory.GetRateProvider(network);
+            if (rateProvider == null)
+                return NotFound();
+
+            if (storeId != null)
+            {
+                var store = await _StoreRepo.FindStore(storeId);
+                if (store == null)
+                    return NotFound();
+                rateProvider = store.GetStoreBlob().ApplyRateRules(network, rateProvider);
+            }
+
+            var allRates = (await rateProvider.GetRatesAsync());
+            return Json(allRates.Select(r =>
                             new NBitpayClient.Rate()
                             {
                                 Code = r.Currency,
                                 Name = _CurrencyNameTable.GetCurrencyData(r.Currency)?.Name,
                                 Value = r.Value
                             }).Where(n => n.Name != null).ToArray());
-
         }
     }
 }

BTCPayServer/Controllers/StoresController.cs

@@ -17,6 +17,7 @@ using NBXplorer.DerivationStrategy;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http;
 using System.Threading.Tasks;
 
 namespace BTCPayServer.Controllers
@@ -30,25 +31,25 @@ namespace BTCPayServer.Controllers
         public StoresController(
             StoreRepository repo,
             TokenRepository tokenRepo,
-            CallbackController callbackController,
             UserManager<ApplicationUser> userManager,
             AccessTokenController tokenController,
-            BTCPayWallet wallet,
+            BTCPayWalletProvider walletProvider,
             BTCPayNetworkProvider networkProvider,
+            ExplorerClientProvider explorerProvider,
             IHostingEnvironment env)
         {
             _Repo = repo;
             _TokenRepository = tokenRepo;
             _UserManager = userManager;
             _TokenController = tokenController;
-            _Wallet = wallet;
+            _WalletProvider = walletProvider;
             _Env = env;
-            _Network = networkProvider.GetNetwork("BTC").NBitcoinNetwork;
-            _CallbackController = callbackController;
+            _NetworkProvider = networkProvider;
+            _ExplorerProvider = explorerProvider;
         }
-        Network _Network;
-        CallbackController _CallbackController;
-        BTCPayWallet _Wallet;
+        BTCPayNetworkProvider _NetworkProvider;
+        private ExplorerClientProvider _ExplorerProvider;
+        BTCPayWalletProvider _WalletProvider;
         AccessTokenController _TokenController;
         StoreRepository _Repo;
         TokenRepository _TokenRepository;
@@ -93,8 +94,15 @@ namespace BTCPayServer.Controllers
             StoresViewModel result = new StoresViewModel();
             result.StatusMessage = StatusMessage;
             var stores = await _Repo.GetStoresByUserId(GetUserId());
-            var balances = stores.Select(async s => string.IsNullOrEmpty(s.DerivationStrategy) ? Money.Zero : await _Wallet.GetBalance(ParseDerivationStrategy(s.DerivationStrategy, null))).ToArray();
+            var balances = stores
+                                .Select(s => s.GetDerivationStrategies(_NetworkProvider)
+                                              .Select(d => (Wallet: _WalletProvider.GetWallet(d.Network),
+                                                            DerivationStrategy: d.DerivationStrategyBase))
+                                              .Where(_ => _.Wallet != null)
+                                              .Select(async _ => (await _.Wallet.GetBalance(_.DerivationStrategy)).ToString() + " " + _.Wallet.Network.CryptoCode))
+                                .ToArray();
 
+            await Task.WhenAll(balances.SelectMany(_ => _));
             for (int i = 0; i < stores.Length; i++)
             {
                 var store = stores[i];
@@ -103,7 +111,7 @@ namespace BTCPayServer.Controllers
                     Id = store.Id,
                     Name = store.StoreName,
                     WebSite = store.StoreWebsite,
-                    Balance = await balances[i]
+                    Balances = balances[i].Select(t => t.Result).ToArray()
                 });
             }
             return View(result);
@@ -149,112 +157,199 @@ namespace BTCPayServer.Controllers
             var vm = new StoreViewModel();
             vm.Id = store.Id;
             vm.StoreName = store.StoreName;
+            vm.SetCryptoCurrencies(_ExplorerProvider, store.GetDefaultCrypto());
             vm.StoreWebsite = store.StoreWebsite;
             vm.NetworkFee = !storeBlob.NetworkFeeDisabled;
             vm.SpeedPolicy = store.SpeedPolicy;
-            vm.DerivationScheme = store.DerivationStrategy;
+            AddDerivationSchemes(store, vm);
             vm.StatusMessage = StatusMessage;
             vm.MonitoringExpiration = storeBlob.MonitoringExpiration;
+            vm.InvoiceExpiration = storeBlob.InvoiceExpiration;
+            vm.RateMultiplier = (double)storeBlob.GetRateMultiplier();
+            vm.PreferredExchange = storeBlob.PreferredExchange.IsCoinAverage() ? "coinaverage" : storeBlob.PreferredExchange;
+            return View(vm);
+        }
+
+        private void AddDerivationSchemes(StoreData store, StoreViewModel vm)
+        {
+            var strategies = store
+                            .GetDerivationStrategies(_NetworkProvider)
+                            .ToDictionary(s => s.Network.CryptoCode);
+            foreach (var explorerProvider in _ExplorerProvider.GetAll())
+            {
+                if (strategies.TryGetValue(explorerProvider.Item1.CryptoCode, out DerivationStrategy strat))
+                {
+                    vm.DerivationSchemes.Add(new StoreViewModel.DerivationScheme()
+                    {
+                        Crypto = explorerProvider.Item1.CryptoCode,
+                        Value = strat.DerivationStrategyBase.ToString()
+                    });
+                }
+            }
+        }
+
+        [HttpGet]
+        [Route("{storeId}/derivations")]
+        public async Task<IActionResult> AddDerivationScheme(string storeId, string selectedScheme = null)
+        {
+            selectedScheme = selectedScheme ?? "BTC";
+            var store = await _Repo.FindStore(storeId, GetUserId());
+            if (store == null)
+                return NotFound();
+            DerivationSchemeViewModel vm = new DerivationSchemeViewModel();
+            vm.SetCryptoCurrencies(_ExplorerProvider, selectedScheme);
             return View(vm);
         }
 
         [HttpPost]
-        [Route("{storeId}")]
-        public async Task<IActionResult> UpdateStore(string storeId, StoreViewModel model, string command)
+        [Route("{storeId}/derivations")]
+        public async Task<IActionResult> AddDerivationScheme(string storeId, DerivationSchemeViewModel vm, string command, string selectedScheme = null)
         {
-            if (!ModelState.IsValid)
-            {
-                return View(model);
-            }
+            selectedScheme = selectedScheme ?? "BTC";
             var store = await _Repo.FindStore(storeId, GetUserId());
             if (store == null)
                 return NotFound();
 
+            var network = vm.CryptoCurrency == null ? null : _ExplorerProvider.GetNetwork(vm.CryptoCurrency);
+            vm.SetCryptoCurrencies(_ExplorerProvider, selectedScheme);
+            if (network == null)
+            {
+                ModelState.AddModelError(nameof(vm.CryptoCurrency), "Invalid network");
+                return View(vm);
+            }
+            var wallet = _WalletProvider.GetWallet(network);
+            if (wallet == null)
+            {
+                ModelState.AddModelError(nameof(vm.CryptoCurrency), "Invalid network");
+                return View(vm);
+            }
+
             if (command == "Save")
             {
-                bool needUpdate = false;
-                if (store.SpeedPolicy != model.SpeedPolicy)
+                try
                 {
-                    needUpdate = true;
-                    store.SpeedPolicy = model.SpeedPolicy;
-                }
-                if (store.StoreName != model.StoreName)
-                {
-                    needUpdate = true;
-                    store.StoreName = model.StoreName;
-                }
-                if (store.StoreWebsite != model.StoreWebsite)
-                {
-                    needUpdate = true;
-                    store.StoreWebsite = model.StoreWebsite;
-                }
-
-                if (store.DerivationStrategy != model.DerivationScheme)
-                {
-                    needUpdate = true;
-                    try
+                    if (!string.IsNullOrEmpty(vm.DerivationScheme))
                     {
-                        if (!string.IsNullOrEmpty(model.DerivationScheme))
-                        {
-                            var strategy = ParseDerivationStrategy(model.DerivationScheme, model.DerivationSchemeFormat);
-                            await _Wallet.TrackAsync(strategy);
-                            await _CallbackController.RegisterCallbackUriAsync(strategy);
-                            model.DerivationScheme = strategy.ToString();
-                        }
-                        store.DerivationStrategy = model.DerivationScheme;
-                    }
-                    catch
-                    {
-                        ModelState.AddModelError(nameof(model.DerivationScheme), "Invalid Derivation Scheme");
-                        return View(model);
+                        var strategy = ParseDerivationStrategy(vm.DerivationScheme, vm.DerivationSchemeFormat, network);
+                        await wallet.TrackAsync(strategy);
+                        vm.DerivationScheme = strategy.ToString();
                     }
+                    store.SetDerivationStrategy(network, vm.DerivationScheme);
+                }
+                catch
+                {
+                    ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
+                    return View(vm);
                 }
 
-                var blob = store.GetStoreBlob();
-                blob.NetworkFeeDisabled = !model.NetworkFee;
-                blob.MonitoringExpiration = model.MonitoringExpiration;
-
-                if (store.SetStoreBlob(blob))
-                {
-                    needUpdate = true;
-                }
-
-                if (needUpdate)
-                {
-                    await _Repo.UpdateStore(store);
-                    StatusMessage = "Store successfully updated";
-                }
-
-                return RedirectToAction(nameof(UpdateStore), new
-                {
-                    storeId = storeId
-                });
+                await _Repo.UpdateStore(store);
+                StatusMessage = $"Derivation scheme for {network.CryptoCode} has been modified.";
+                return RedirectToAction(nameof(UpdateStore), new { storeId = storeId });
             }
             else
             {
-                if (!string.IsNullOrEmpty(model.DerivationScheme))
+                if (!string.IsNullOrEmpty(vm.DerivationScheme))
                 {
                     try
                     {
-                        var scheme = ParseDerivationStrategy(model.DerivationScheme, model.DerivationSchemeFormat);
+                        var scheme = ParseDerivationStrategy(vm.DerivationScheme, vm.DerivationSchemeFormat, network);
                         var line = scheme.GetLineFor(DerivationFeature.Deposit);
 
                         for (int i = 0; i < 10; i++)
                         {
                             var address = line.Derive((uint)i);
-                            model.AddressSamples.Add((line.Path.Derive((uint)i).ToString(), address.ScriptPubKey.GetDestinationAddress(_Network).ToString()));
+                            vm.AddressSamples.Add((line.Path.Derive((uint)i).ToString(), address.ScriptPubKey.GetDestinationAddress(network.NBitcoinNetwork).ToString()));
                         }
                     }
                     catch
                     {
-                        ModelState.AddModelError(nameof(model.DerivationScheme), "Invalid Derivation Scheme");
+                        ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
                     }
                 }
-                return View(model);
+                return View(vm);
             }
         }
 
-        private DerivationStrategyBase ParseDerivationStrategy(string derivationScheme, string format)
+        [HttpPost]
+        [Route("{storeId}")]
+        public async Task<IActionResult> UpdateStore(string storeId, StoreViewModel model)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
+            if (model.PreferredExchange != null)
+                model.PreferredExchange = model.PreferredExchange.Trim().ToLowerInvariant();
+            var store = await _Repo.FindStore(storeId, GetUserId());
+            if (store == null)
+                return NotFound();
+            AddDerivationSchemes(store, model);
+
+            bool needUpdate = false;
+            if (store.SpeedPolicy != model.SpeedPolicy)
+            {
+                needUpdate = true;
+                store.SpeedPolicy = model.SpeedPolicy;
+            }
+            if (store.StoreName != model.StoreName)
+            {
+                needUpdate = true;
+                store.StoreName = model.StoreName;
+            }
+            if (store.StoreWebsite != model.StoreWebsite)
+            {
+                needUpdate = true;
+                store.StoreWebsite = model.StoreWebsite;
+            }
+
+            if (store.GetDefaultCrypto() != model.DefaultCryptoCurrency)
+            {
+                needUpdate = true;
+                store.SetDefaultCrypto(model.DefaultCryptoCurrency);
+            }
+            model.SetCryptoCurrencies(_ExplorerProvider, model.DefaultCryptoCurrency);
+
+            var blob = store.GetStoreBlob();
+            blob.NetworkFeeDisabled = !model.NetworkFee;
+            blob.MonitoringExpiration = model.MonitoringExpiration;
+            blob.InvoiceExpiration = model.InvoiceExpiration;
+
+            bool newExchange = blob.PreferredExchange != model.PreferredExchange;
+            blob.PreferredExchange = model.PreferredExchange;
+
+            blob.SetRateMultiplier(model.RateMultiplier);
+
+            if (store.SetStoreBlob(blob))
+            {
+                needUpdate = true;
+            }
+
+            if (!blob.PreferredExchange.IsCoinAverage() && newExchange)
+            {
+                using (HttpClient client = new HttpClient())
+                {
+                    var rate = await client.GetAsync(model.RateSource);
+                    if (rate.StatusCode == System.Net.HttpStatusCode.NotFound)
+                    {
+                        ModelState.AddModelError(nameof(model.PreferredExchange), $"Unsupported exchange ({model.RateSource})");
+                        return View(model);
+                    }
+                }
+            }
+
+            if (needUpdate)
+            {
+                await _Repo.UpdateStore(store);
+                StatusMessage = "Store successfully updated";
+            }
+
+            return RedirectToAction(nameof(UpdateStore), new
+            {
+                storeId = storeId
+            });
+        }
+
+        private DerivationStrategyBase ParseDerivationStrategy(string derivationScheme, string format, BTCPayNetwork network)
         {
             if (format == "Electrum")
             {
@@ -276,19 +371,19 @@ 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(_Network == Network.Main ? 0x0488b21eU : 0x043587cf, false);
+                var standardPrefix = Utils.ToBytes(network.NBXplorerNetwork.DefaultSettings.ChainType == NBXplorer.ChainType.Main ? 0x0488b21eU : 0x043587cf, false);
 
                 for (int i = 0; i < 4; i++)
                     data[i] = standardPrefix[i];
 
-                derivationScheme = new BitcoinExtPubKey(Encoders.Base58Check.EncodeData(data), _Network).ToString();
+                derivationScheme = new BitcoinExtPubKey(Encoders.Base58Check.EncodeData(data), network.NBitcoinNetwork).ToString();
                 foreach (var label in labels)
                 {
                     derivationScheme = derivationScheme + $"-[{label}]";
                 }
             }
 
-            return new DerivationStrategyFactory(_Network).Parse(derivationScheme);
+            return new DerivationStrategyFactory(network.NBitcoinNetwork).Parse(derivationScheme);
         }
 
         [HttpGet]
@@ -354,6 +449,7 @@ namespace BTCPayServer.Controllers
                 pairingCode = ((DataWrapper<List<PairingCodeResponse>>)await _TokenController.Tokens(tokenRequest)).Data[0].PairingCode;
             }
 
+            GeneratedPairingCode = pairingCode;
             return RedirectToAction(nameof(RequestPairing), new
             {
                 pairingCode = pairingCode,
@@ -361,6 +457,8 @@ namespace BTCPayServer.Controllers
             });
         }
 
+        public string GeneratedPairingCode { get; set; }
+
         [HttpGet]
         [Route("/api-tokens")]
         [Route("{storeId}/Tokens/Create")]

BTCPayServer/Data/AddressInvoiceData.cs

@@ -2,16 +2,49 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using NBitcoin;
 
 namespace BTCPayServer.Data
 {
     public class AddressInvoiceData
     {
+        /// <summary>
+        /// Some crypto currencies share same address prefix
+        /// For not having exceptions thrown by two address on different network, we suffix by "#CRYPTOCODE" 
+        /// </summary>
+        [Obsolete("Use GetHash instead")]
         public string Address
         {
             get; set;
         }
 
+
+#pragma warning disable CS0618
+        public ScriptId GetHash()
+        {
+            if (Address == null)
+                return null;
+            var index = Address.IndexOf("#");
+            if (index == -1)
+                return new ScriptId(Address);
+            return new ScriptId(Address.Substring(0, index));
+        }
+        public AddressInvoiceData SetHash(ScriptId scriptId, string cryptoCode)
+        {
+            Address = scriptId + "#" + cryptoCode;
+            return this;
+        }
+        public string GetCryptoCode()
+        {
+            if (Address == null)
+                return null;
+            var index = Address.IndexOf("#");
+            if (index == -1)
+                return "BTC";
+            return Address.Substring(index + 1);
+        }
+#pragma warning restore CS0618
+
         public InvoiceData InvoiceData
         {
             get; set;
@@ -26,5 +59,6 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
+
     }
 }

BTCPayServer/Data/ApplicationDbContext.cs

@@ -26,6 +26,11 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        public DbSet<InvoiceEventData> InvoiceEvents
+        {
+            get; set;
+        }
+
         public DbSet<HistoricalAddressInvoiceData> HistoricalAddressInvoices
         {
             get; set;
@@ -113,7 +118,9 @@ namespace BTCPayServer.Data
                 .HasForeignKey(pt => pt.StoreDataId);
 
             builder.Entity<AddressInvoiceData>()
+#pragma warning disable CS0618
                 .HasKey(o => o.Address);
+#pragma warning restore CS0618
 
             builder.Entity<PairingCodeData>()
                 .HasKey(o => o.Id);
@@ -128,7 +135,18 @@ namespace BTCPayServer.Data
                 .HasKey(o => new
                 {
                     o.InvoiceDataId,
+#pragma warning disable CS0618
                     o.Address
+#pragma warning restore CS0618
+                });
+
+            builder.Entity<InvoiceEventData>()
+                .HasKey(o => new
+                {
+                    o.InvoiceDataId,
+#pragma warning disable CS0618
+                    o.UniqueId
+#pragma warning restore CS0618
                 });
         }
     }

BTCPayServer/Data/HistoricalAddressInvoiceData.cs

@@ -12,6 +12,11 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        /// <summary>
+        /// Some crypto currencies share same address prefix
+        /// For not having exceptions thrown by two address on different network, we suffix by "#CRYPTOCODE" 
+        /// </summary>
+        [Obsolete("Use GetCryptoCode instead")]
         public string Address
         {
             get; set;
@@ -26,6 +31,21 @@ namespace BTCPayServer.Data
         {
             return string.IsNullOrEmpty(CryptoCode) ? "BTC" : CryptoCode;
         }
+        public string GetAddress()
+        {
+            if (Address == null)
+                return null;
+            var index = Address.IndexOf("#");
+            if (index == -1)
+                return Address;
+            return Address.Substring(0, index);
+        }
+        public HistoricalAddressInvoiceData SetAddress(string depositAddress, string cryptoCode)
+        {
+            Address = depositAddress + "#" + cryptoCode;
+            CryptoCode = cryptoCode;
+            return this;
+        }
 #pragma warning restore CS0618
 
         public DateTimeOffset Assigned

BTCPayServer/Data/InvoiceData.cs

@@ -32,6 +32,11 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        public List<InvoiceEventData> Events
+        {
+            get; set;
+        }
+
         public List<RefundAddressesData> RefundAddresses
         {
             get; set;

BTCPayServer/Data/InvoiceEventData.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Data
+{
+    public class InvoiceEventData
+    {
+        public string InvoiceDataId
+        {
+            get; set;
+        }
+        public string UniqueId { get; internal set; }
+        public DateTimeOffset Timestamp
+        {
+            get; set;
+        }
+
+        public string Message { get; set; }
+    }
+}

BTCPayServer/Data/StoreData.cs

@@ -10,6 +10,8 @@ using System.Text;
 using System.Threading.Tasks;
 using System.ComponentModel;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using BTCPayServer.Services.Rates;
 
 namespace BTCPayServer.Data
 {
@@ -26,11 +28,90 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        [Obsolete("Use GetDerivationStrategies instead")]
         public string DerivationStrategy
         {
             get; set;
         }
 
+        [Obsolete("Use GetDerivationStrategies instead")]
+        public string DerivationStrategies
+        {
+            get;
+            set;
+        }
+
+        public IEnumerable<DerivationStrategy> GetDerivationStrategies(BTCPayNetworkProvider networks)
+        {
+#pragma warning disable CS0618
+            bool btcReturned = false;
+            if (!string.IsNullOrEmpty(DerivationStrategy))
+            {
+                if (networks.BTC != null)
+                {
+                    btcReturned = true;
+                    yield return BTCPayServer.DerivationStrategy.Parse(DerivationStrategy, networks.BTC);
+                }
+            }
+
+
+            if (!string.IsNullOrEmpty(DerivationStrategies))
+            {
+                JObject strategies = JObject.Parse(DerivationStrategies);
+                foreach (var strat in strategies.Properties())
+                {
+                    var network = networks.GetNetwork(strat.Name);
+                    if (network != null)
+                    {
+                        if (network == networks.BTC && btcReturned)
+                            continue;
+                        if (strat.Value.Type == JTokenType.Null)
+                            continue;
+                        yield return BTCPayServer.DerivationStrategy.Parse(strat.Value.Value<string>(), network);
+                    }
+                }
+            }
+#pragma warning restore CS0618
+        }
+
+        public void SetDerivationStrategy(BTCPayNetwork network, string derivationScheme)
+        {
+#pragma warning disable CS0618
+            JObject strategies = string.IsNullOrEmpty(DerivationStrategies) ? new JObject() : JObject.Parse(DerivationStrategies);
+            bool existing = false;
+            foreach (var strat in strategies.Properties().ToList())
+            {
+                if (strat.Name == network.CryptoCode)
+                {
+                    if (network.IsBTC)
+                        DerivationStrategy = null;
+                    if (string.IsNullOrEmpty(derivationScheme))
+                    {
+                        strat.Remove();
+                    }
+                    else
+                    {
+                        strat.Value = new JValue(derivationScheme);
+                    }
+                    existing = true;
+                    break;
+                }
+            }
+
+            if (!existing && string.IsNullOrEmpty(derivationScheme))
+            {
+                if (network.IsBTC)
+                    DerivationStrategy = null;
+            }
+            else if (!existing)
+                strategies.Add(new JProperty(network.CryptoCode, new JValue(derivationScheme)));
+            // This is deprecated so we don't have to set anymore
+            //if (network.IsBTC)
+            //    DerivationStrategy = derivationScheme;
+            DerivationStrategies = strategies.ToString();
+#pragma warning restore CS0618
+        }
+
         public string StoreName
         {
             get; set;
@@ -61,6 +142,19 @@ namespace BTCPayServer.Data
             get;
             set;
         }
+        [Obsolete("Use GetDefaultCrypto instead")]
+        public string DefaultCrypto { get; set; }
+
+#pragma warning disable CS0618
+        public string GetDefaultCrypto()
+        {
+            return DefaultCrypto ?? "BTC";
+        }
+        public void SetDefaultCrypto(string defaultCryptoCurrency)
+        {
+            DefaultCrypto = defaultCryptoCurrency;
+        }
+#pragma warning restore CS0618
 
         static Network Dummy = Network.Main;
 
@@ -80,10 +174,27 @@ namespace BTCPayServer.Data
         }
     }
 
+    public class RateRule
+    {
+        public RateRule()
+        {
+            RuleName = "Multiplier";
+        }
+        public string RuleName { get; set; }
+
+        public double Multiplier { get; set; }
+
+        public decimal Apply(BTCPayNetwork network, decimal rate)
+        {
+            return rate * (decimal)Multiplier;
+        }
+    }
+
     public class StoreBlob
     {
         public StoreBlob()
         {
+            InvoiceExpiration = 15;
             MonitoringExpiration = 60;
         }
         public bool NetworkFeeDisabled
@@ -98,18 +209,58 @@ namespace BTCPayServer.Data
             set;
         }
 
-        [Obsolete("Use GetSupportedCryptoCurrencies() instead")]
-        public string[] SupportedCryptoCurrencies { get; set; }
-
-        public string[] GetSupportedCryptoCurrencies()
+        [DefaultValue(15)]
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        public int InvoiceExpiration
         {
-#pragma warning disable CS0618
-            if(SupportedCryptoCurrencies == null)
+            get;
+            set;
+        }
+
+        public void SetRateMultiplier(double rate)
+        {
+            RateRules = new List<RateRule>();
+            RateRules.Add(new RateRule() { Multiplier = rate });
+        }
+        public decimal GetRateMultiplier()
+        {
+            decimal rate = 1.0m;
+            if (RateRules == null || RateRules.Count == 0)
+                return rate;
+            foreach (var rule in RateRules)
             {
-                return new string[] { "BTC" };
+                rate = rule.Apply(null, rate);
             }
-            return SupportedCryptoCurrencies;
-#pragma warning restore CS0618
+            return rate;
+        }
+
+        public List<RateRule> RateRules { get; set; } = new List<RateRule>();
+        public string PreferredExchange { get; set; }
+
+        public IRateProvider ApplyRateRules(BTCPayNetwork network, IRateProvider rateProvider)
+        {
+            if (!PreferredExchange.IsCoinAverage())
+            {
+                // If the original rateProvider is a cache, use the same inner provider as fallback, and same memory cache to wrap it all
+                if (rateProvider is CachedRateProvider cachedRateProvider)
+                {
+                    rateProvider = new FallbackRateProvider(new IRateProvider[] {
+                        new CoinAverageRateProvider(network.CryptoCode) { Exchange = PreferredExchange },
+                        cachedRateProvider.Inner
+                    });
+                    rateProvider = new CachedRateProvider(network.CryptoCode, rateProvider, cachedRateProvider.MemoryCache) { AdditionalScope = PreferredExchange };
+                }
+                else
+                {
+                    rateProvider = new FallbackRateProvider(new IRateProvider[] {
+                        new CoinAverageRateProvider(network.CryptoCode) { Exchange = PreferredExchange },
+                        rateProvider
+                    });
+                }
+            }
+            if (RateRules == null || RateRules.Count == 0)
+                return rateProvider;
+            return new TweakRateProvider(network, rateProvider, RateRules.ToList());
         }
     }
 }

BTCPayServer/DerivationStrategy.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer.DerivationStrategy;
+
+namespace BTCPayServer
+{
+    public class DerivationStrategy
+    {
+        private DerivationStrategyBase _DerivationStrategy;
+        private BTCPayNetwork _Network;
+
+        DerivationStrategy(DerivationStrategyBase result, BTCPayNetwork network)
+        {
+            this._DerivationStrategy = result;
+            this._Network = network;
+        }
+        
+        public static DerivationStrategy Parse(string derivationStrategy, BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            if (derivationStrategy == null)
+                throw new ArgumentNullException(nameof(derivationStrategy));
+            var result = new NBXplorer.DerivationStrategy.DerivationStrategyFactory(network.NBitcoinNetwork).Parse(derivationStrategy);
+            return new DerivationStrategy(result, network);
+        }
+
+        public BTCPayNetwork Network { get { return this._Network; } }
+
+        public DerivationStrategyBase DerivationStrategyBase { get { return this._DerivationStrategy; } }
+
+        public override string ToString()
+        {
+            return _DerivationStrategy.ToString();
+        }
+    }
+}

BTCPayServer/EventAggregator.cs

@@ -71,19 +71,24 @@ namespace BTCPayServer
         }
 
         public void Publish<T>(T evt) where T : class
+        {
+            Publish(evt, typeof(T));
+        }
+
+        public void Publish(object evt, Type evtType)
         {
             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))
+                if (_Subscriptions.TryGetValue(evtType, out Dictionary<Subscription, Action<object>> actions))
                 {
                     actionList = actions.Values.ToList();
                 }
             }
 
-            Logs.Events.LogInformation($"New event: {evt.ToString()}");
+            Logs.Events.LogInformation(evt.ToString());
             foreach (var sub in actionList)
             {
                 try

BTCPayServer/Events/InvoiceDataChangedEvent.cs

@@ -8,10 +8,19 @@ namespace BTCPayServer.Events
     public class InvoiceDataChangedEvent
     {
         public string InvoiceId { get; set; }
+        public string Status { get; internal set; }
+        public string ExceptionStatus { get; internal set; }
 
         public override string ToString()
         {
-            return $"Invoice {InvoiceId} data changed";
+            if (string.IsNullOrEmpty(ExceptionStatus) || ExceptionStatus == "false")
+            { 
+                return $"Invoice status is {Status}";
+            }
+            else
+            {
+                return $"Invoice status is {Status} (Exception status: {ExceptionStatus})";
+            }
         }
     }
 }

BTCPayServer/Events/InvoiceEvent.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceEvent
+    {
+        public InvoiceEvent(InvoiceEntity invoice, int code, string name) : this(invoice.Id, code, name)
+        {
+
+        }
+        public InvoiceEvent(string invoiceId, int code, string name)
+        {
+            InvoiceId = invoiceId;
+            EventCode = code;
+            Name = name;
+        }
+
+        public string InvoiceId { get; set; }
+        public int EventCode { get; set; }
+        public string Name { get; set; }
+
+        public override string ToString()
+        {
+            return $"Invoice {InvoiceId} new event: {Name} ({EventCode})";
+        }
+    }
+}

BTCPayServer/Events/InvoiceIPNEvent.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceIPNEvent
+    {
+        public InvoiceIPNEvent(string invoiceId, int? eventCode, string name)
+        {
+            InvoiceId = invoiceId;
+            EventCode = eventCode;
+            Name = name;
+        }
+
+        public int? EventCode { get; set; }
+        public string Name { get; set; }
+
+        public string InvoiceId { get; set; }
+        public string Error { get; set; }
+
+        public override string ToString()
+        {
+            string ipnType = "IPN";
+            if(EventCode.HasValue)
+            {
+                ipnType = $"IPN ({EventCode.Value} {Name})";
+            }
+            if (Error == null)
+                return $"{ipnType} sent for invoice {InvoiceId}";
+            return $"Error while sending {ipnType}: {Error}";
+        }
+    }
+}

BTCPayServer/Events/InvoicePaymentEvent.cs

@@ -1,24 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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/InvoiceStopWatchedEvent.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceStopWatchedEvent
+    {
+        public string InvoiceId { get; set; }
+        public override string ToString()
+        {
+            return $"Invoice {InvoiceId} is not monitored anymore.";
+        }
+    }
+}

BTCPayServer/Events/NBXplorerStateChangedEvent.cs

@@ -2,23 +2,41 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.HostedServices;
 
 namespace BTCPayServer.Events
 {
+    public class NBXplorerErrorEvent
+    {
+        public NBXplorerErrorEvent(BTCPayNetwork network, string errorMessage)
+        {
+            Message = errorMessage;
+            Network = network;
+        }
+        public string Message { get; set; }
+        public BTCPayNetwork Network { get; set; }
+
+        public override string ToString()
+        {
+            return $"{Network.CryptoCode}: NBXplorer error `{Message}`";
+        }
+    }
     public class NBXplorerStateChangedEvent
     {
-        public NBXplorerStateChangedEvent(NBXplorerState old, NBXplorerState newState)
+        public NBXplorerStateChangedEvent(BTCPayNetwork network, NBXplorerState old, NBXplorerState newState)
         {
+            Network = network;
             NewState = newState;
             OldState = old;
         }
 
+        public BTCPayNetwork Network { get; set; }
         public NBXplorerState NewState { get; set; }
         public NBXplorerState OldState { get; set; }
 
         public override string ToString()
         {
-            return $"NBXplorer: {OldState} => {NewState}";
+            return $"NBXplorer {Network.CryptoCode}: {OldState} => {NewState}";
         }
     }
 }

BTCPayServer/Events/NewBlockEvent.cs

@@ -7,9 +7,10 @@ namespace BTCPayServer.Events
 {
     public class NewBlockEvent
     {
+        public string CryptoCode { get; set; }
         public override string ToString()
         {
-            return "New block";
+            return $"{CryptoCode}: New block";
         }
     }
 }

BTCPayServer/Events/TxOutReceivedEvent.cs

@@ -8,13 +8,13 @@ namespace BTCPayServer.Events
 {
     public class TxOutReceivedEvent
     {
+        public BTCPayNetwork Network { get; set; }
         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";
+            String address = ScriptPubKey.GetDestinationAddress(Network.NBitcoinNetwork)?.ToString() ?? ScriptPubKey.ToString();
+            return $"{address} received a transaction ({Network.CryptoCode})";
         }
     }
 }

BTCPayServer/ExplorerClientProvider.cs

@@ -0,0 +1,104 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Configuration;
+using BTCPayServer.Logging;
+using NBXplorer;
+using BTCPayServer.HostedServices;
+
+namespace BTCPayServer
+{
+    public class ExplorerClientProvider
+    {
+        BTCPayNetworkProvider _NetworkProviders;
+        BTCPayServerOptions _Options;
+
+        public BTCPayNetworkProvider NetworkProviders => _NetworkProviders;
+        NBXplorerDashboard _Dashboard;
+        public ExplorerClientProvider(BTCPayNetworkProvider networkProviders, BTCPayServerOptions options, NBXplorerDashboard dashboard)
+        {
+            _Dashboard = dashboard;
+            _NetworkProviders = networkProviders;
+            _Options = options;
+
+            foreach (var setting in options.NBXplorerConnectionSettings)
+            {
+                var cookieFile = setting.CookieFile;
+                if (cookieFile.Trim() == "0" || string.IsNullOrEmpty(cookieFile.Trim()))
+                    cookieFile = null;
+                Logs.Configuration.LogInformation($"{setting.CryptoCode}: Explorer url is {(setting.ExplorerUri.AbsoluteUri ?? "not set")}");
+                Logs.Configuration.LogInformation($"{setting.CryptoCode}: Cookie file is {(setting.CookieFile ?? "not set")}");
+                if (setting.ExplorerUri != null)
+                {
+                    _Clients.TryAdd(setting.CryptoCode, CreateExplorerClient(_NetworkProviders.GetNetwork(setting.CryptoCode), setting.ExplorerUri, setting.CookieFile));
+                }
+            }
+        }
+
+        private static ExplorerClient CreateExplorerClient(BTCPayNetwork n, Uri uri, string cookieFile)
+        {
+            var explorer = new ExplorerClient(n.NBXplorerNetwork, uri);
+            if (cookieFile == null)
+            {
+                Logs.Configuration.LogWarning($"{n.CryptoCode}: Not using cookie authentication");
+                explorer.SetNoAuth();
+            }
+            if(!explorer.SetCookieAuth(cookieFile))
+            {
+                Logs.Configuration.LogWarning($"{n.CryptoCode}: Using cookie auth against NBXplorer, but {cookieFile} is not found");
+            }
+            return explorer;
+        }
+
+        Dictionary<string, ExplorerClient> _Clients = new Dictionary<string, ExplorerClient>();
+
+        public ExplorerClient GetExplorerClient(string cryptoCode)
+        {
+            var network = _NetworkProviders.GetNetwork(cryptoCode);
+            if (network == null)
+                return null;
+            _Clients.TryGetValue(network.CryptoCode, out ExplorerClient client);
+            return client;
+        }
+
+        public ExplorerClient GetExplorerClient(BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            return GetExplorerClient(network.CryptoCode);
+        }
+
+        public bool IsAvailable(BTCPayNetwork network)
+        {
+            return IsAvailable(network.CryptoCode);
+        }
+
+        public bool IsAvailable(string cryptoCode)
+        {
+            return _Clients.ContainsKey(cryptoCode) && _Dashboard.IsFullySynched(cryptoCode);
+        }
+
+        public BTCPayNetwork GetNetwork(string cryptoCode)
+        {
+            var network = _NetworkProviders.GetNetwork(cryptoCode);
+            if (network == null)
+                return null;
+            if (_Clients.ContainsKey(network.CryptoCode))
+                return network;
+            return null;
+        }
+
+        public IEnumerable<(BTCPayNetwork, ExplorerClient)> GetAll()
+        {
+            foreach (var net in _NetworkProviders.GetAll())
+            {
+                if (_Clients.TryGetValue(net.CryptoCode, out ExplorerClient explorer))
+                {
+                    yield return (net, explorer);
+                }
+            }
+        }
+    }
+}

BTCPayServer/Extensions.cs

@@ -17,12 +17,27 @@ using NBXplorer;
 using NBXplorer.Models;
 using System.Linq;
 using System.Threading;
+using BTCPayServer.Services.Wallets;
+using System.IO;
+using BTCPayServer.Logging;
+using Microsoft.Extensions.Logging;
 
 namespace BTCPayServer
 {
     public static class Extensions
     {
-        public static async Task<Dictionary<uint256, TransactionResult>> GetTransactions(this ExplorerClient client, uint256[] hashes, CancellationToken cts = default(CancellationToken))
+        public static bool SupportDropColumn(this Microsoft.EntityFrameworkCore.Migrations.Migration migration, string activeProvider)
+        {
+            return activeProvider != "Microsoft.EntityFrameworkCore.Sqlite";
+        }
+
+        public static bool IsCoinAverage(this string exchangeName)
+        {
+            string[] coinAverages = new[] { "coinaverage", "bitcoinaverage" };
+            return String.IsNullOrWhiteSpace(exchangeName) ? true : coinAverages.Contains(exchangeName, StringComparer.OrdinalIgnoreCase) ? true : false;
+        }
+
+        public static async Task<Dictionary<uint256, TransactionResult>> GetTransactions(this BTCPayWallet client, uint256[] hashes, CancellationToken cts = default(CancellationToken))
         {
             hashes = hashes.Distinct().ToArray();
             var transactions = hashes

BTCPayServer/HostedServices/InvoiceNotificationManager.cs

@@ -17,8 +17,10 @@ using Newtonsoft.Json;
 using System.Collections.Concurrent;
 using Microsoft.Extensions.Hosting;
 using BTCPayServer.Events;
+using NBXplorer;
+using BTCPayServer.Services.Invoices;
 
-namespace BTCPayServer.Services.Invoices
+namespace BTCPayServer.HostedServices
 {
     public class InvoiceNotificationManager : IHostedService
     {
@@ -35,6 +37,9 @@ namespace BTCPayServer.Services.Invoices
             {
                 get; set;
             }
+
+            public int? EventCode { get; set; }
+            public string Message { get; set; }
         }
 
         public ILogger Logger
@@ -61,18 +66,32 @@ namespace BTCPayServer.Services.Invoices
             _NetworkProvider = networkProvider;
         }
 
-        async Task Notify(InvoiceEntity invoice)
+        async Task Notify(InvoiceEntity invoice, int? eventCode = null, string name = null)
         {
             CancellationTokenSource cts = new CancellationTokenSource(10000);
             try
             {
-                await SendNotification(invoice, cts.Token);
+                if (string.IsNullOrEmpty(invoice.NotificationURL))
+                    return;
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name));
+                await SendNotification(invoice, eventCode, name, cts.Token);
                 return;
             }
-            catch // It fails, it is OK because we try with hangfire after
+            catch (OperationCanceledException) when (cts.IsCancellationRequested)
             {
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name)
+                {
+                    Error = "Timeout"
+                });
             }
-            var invoiceStr = NBitcoin.JsonConverters.Serializer.ToString(new ScheduledJob() { TryCount = 0, Invoice = invoice });
+            catch (Exception ex) // It fails, it is OK because we try with hangfire after
+            {
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name)
+                {
+                    Error = ex.Message
+                });
+            }
+            var invoiceStr = NBitcoin.JsonConverters.Serializer.ToString(new ScheduledJob() { TryCount = 0, Invoice = invoice, EventCode = eventCode, Message = name });
             if (!string.IsNullOrEmpty(invoice.NotificationURL))
                 _JobClient.Schedule(() => NotifyHttp(invoiceStr), TimeSpan.Zero);
         }
@@ -91,14 +110,45 @@ namespace BTCPayServer.Services.Invoices
             CancellationTokenSource cts = new CancellationTokenSource(10000);
             try
             {
-                HttpResponseMessage response = await SendNotification(job.Invoice, cts.Token);
+                HttpResponseMessage response = await SendNotification(job.Invoice, job.EventCode, job.Message, cts.Token);
                 reschedule = response.StatusCode != System.Net.HttpStatusCode.OK;
                 Logger.LogInformation("Job " + jobId + " returned " + response.StatusCode);
+
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
+                {
+                    Error = reschedule ? $"Unexpected return code: {(int)response.StatusCode}" : null
+                });
             }
-            catch (Exception ex)
+            catch (OperationCanceledException) when (cts.IsCancellationRequested)
             {
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
+                {
+                    Error = "Timeout"
+                });
                 reschedule = true;
-                Logger.LogInformation("Job " + jobId + " threw exception " + ex.Message);
+                Logger.LogInformation("Job " + jobId + " timed out");
+            }
+            catch (Exception ex) // It fails, it is OK because we try with hangfire after
+            {
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
+                {
+                    Error = ex.Message
+                });
+                reschedule = true;
+
+                List<string> messages = new List<string>();
+                while(ex != null)
+                {
+                    messages.Add(ex.Message);
+                    ex = ex.InnerException;
+                }
+                string message = String.Join(',', messages.ToArray());
+                Logger.LogInformation("Job " + jobId + " threw exception " + message);
+
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
+                {
+                    Error = $"Unexpected error: {message}"
+                });
             }
             finally { cts.Dispose(); _Executing.TryRemove(jobId, out jobId); }
 
@@ -113,7 +163,23 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        private async Task<HttpResponseMessage> SendNotification(InvoiceEntity invoice, CancellationToken cancellation)
+        public class InvoicePaymentNotificationEvent
+        {
+            [JsonProperty("code")]
+            public int Code { get; set; }
+            [JsonProperty("name")]
+            public string Name { get; set; }
+        }
+        public class InvoicePaymentNotificationEventWrapper
+        {
+            [JsonProperty("event")]
+            public InvoicePaymentNotificationEvent Event { get; set; }
+            [JsonProperty("data")]
+            public InvoicePaymentNotification Data { get; set; }
+        }
+
+        Encoding UTF8 = new UTF8Encoding(false);
+        private async Task<HttpResponseMessage> SendNotification(InvoiceEntity invoice, int? eventCode, string name, CancellationToken cancellation)
         {
             var request = new HttpRequestMessage();
             request.Method = HttpMethod.Post;
@@ -136,7 +202,7 @@ namespace BTCPayServer.Services.Invoices
             // We keep backward compatibility with bitpay by passing BTC info to the notification
             // we don't pass other info, as it is a bad idea to use IPN data for logic processing (can be faked)
             var btcCryptoInfo = dto.CryptoInfo.FirstOrDefault(c => c.CryptoCode == "BTC");
-            if(btcCryptoInfo != null)
+            if (btcCryptoInfo != null)
             {
 #pragma warning disable CS0618
                 notification.Rate = (double)dto.Rate;
@@ -146,8 +212,22 @@ namespace BTCPayServer.Services.Invoices
                 notification.BTCPrice = dto.BTCPrice;
 #pragma warning restore CS0618
             }
+
+            string notificationString = null;
+            if (eventCode.HasValue)
+            {
+                var wrapper = new InvoicePaymentNotificationEventWrapper();
+                wrapper.Data = notification;
+                wrapper.Event = new InvoicePaymentNotificationEvent() { Code = eventCode.Value, Name = name };
+                notificationString = JsonConvert.SerializeObject(wrapper);
+            }
+            else
+            {
+                notificationString = JsonConvert.SerializeObject(notification);
+            }
+
             request.RequestUri = new Uri(invoice.NotificationURL, UriKind.Absolute);
-            request.Content = new StringContent(JsonConvert.SerializeObject(notification), Encoding.UTF8, "application/json");
+            request.Content = new StringContent(notificationString, UTF8, "application/json");
             var response = await _Client.SendAsync(request, cancellation);
             return response;
         }
@@ -162,29 +242,60 @@ namespace BTCPayServer.Services.Invoices
         CompositeDisposable leases = new CompositeDisposable();
         public Task StartAsync(CancellationToken cancellationToken)
         {
-            leases.Add(_EventAggregator.Subscribe<InvoiceStatusChangedEvent>(async e => 
+            leases.Add(_EventAggregator.Subscribe<InvoiceEvent>(async e =>
             {
                 var invoice = await _InvoiceRepository.GetInvoice(null, e.InvoiceId);
+                await SaveEvent(invoice.Id, e);
 
                 // 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"
+                    if (e.Name == "invoice_expired" ||
+                       e.Name == "invoice_paidInFull" ||
+                       e.Name == "invoice_failedToConfirm" ||
+                       e.Name == "invoice_markedInvalid" ||
+                       e.Name == "invoice_failedToConfirm" ||
+                       e.Name == "invoice_completed"
                      )
                         await Notify(invoice);
                 }
-                
-                if(e.NewState == "confirmed")
+
+                if (e.Name == "invoice_confirmed")
                 {
                     await Notify(invoice);
                 }
+
+                if (invoice.ExtendedNotifications)
+                {
+                    await Notify(invoice, e.EventCode, e.Name);
+                }
             }));
+
+
+            leases.Add(_EventAggregator.Subscribe<InvoiceDataChangedEvent>(async e =>
+            {
+                await SaveEvent(e.InvoiceId, e);
+            }));
+
+
+            leases.Add(_EventAggregator.Subscribe<InvoiceStopWatchedEvent>(async e =>
+            {
+                await SaveEvent(e.InvoiceId, e);
+            }));
+
+            leases.Add(_EventAggregator.Subscribe<InvoiceIPNEvent>(async e =>
+            {
+                await SaveEvent(e.InvoiceId, e);
+            }));
+
             return Task.CompletedTask;
         }
 
+        private Task SaveEvent(string invoiceId, object evt)
+        {
+            return _InvoiceRepository.AddInvoiceEvent(invoiceId, evt);
+        }
+
         public Task StopAsync(CancellationToken cancellationToken)
         {
             leases.Dispose();

BTCPayServer/HostedServices/InvoiceWatcher.cs

@@ -0,0 +1,531 @@
+using NBXplorer;
+using Microsoft.Extensions.Logging;
+using NBXplorer.DerivationStrategy;
+using NBXplorer.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using BTCPayServer.Logging;
+using System.Threading;
+using Microsoft.Extensions.Hosting;
+using System.Collections.Concurrent;
+using Hangfire;
+using BTCPayServer.Services.Wallets;
+using BTCPayServer.Controllers;
+using BTCPayServer.Events;
+using Microsoft.AspNetCore.Hosting;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services;
+
+namespace BTCPayServer.HostedServices
+{
+    public class InvoiceWatcher : IHostedService
+    {
+        class UpdateInvoiceContext
+        {
+            public UpdateInvoiceContext()
+            {
+
+            }
+
+            public Dictionary<BTCPayNetwork, KnownState> KnownStates { get; set; }
+            public Dictionary<BTCPayNetwork, KnownState> ModifiedKnownStates { get; set; } = new Dictionary<BTCPayNetwork, KnownState>();
+            public InvoiceEntity Invoice { get; set; }
+            public List<object> Events { get; set; } = new List<object>();
+
+            bool _Dirty = false;
+            public void MarkDirty()
+            {
+                _Dirty = true;
+            }
+
+            public bool Dirty => _Dirty;
+        }
+
+        InvoiceRepository _InvoiceRepository;
+        EventAggregator _EventAggregator;
+        BTCPayWalletProvider _WalletProvider;
+        BTCPayNetworkProvider _NetworkProvider;
+
+        public InvoiceWatcher(
+            IHostingEnvironment env,
+            BTCPayNetworkProvider networkProvider,
+            InvoiceRepository invoiceRepository,
+            EventAggregator eventAggregator,
+            BTCPayWalletProvider walletProvider)
+        {
+            PollInterval = TimeSpan.FromMinutes(1.0);
+            _WalletProvider = walletProvider ?? throw new ArgumentNullException(nameof(walletProvider));
+            _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
+            _EventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
+            _NetworkProvider = networkProvider;
+        }
+        CompositeDisposable leases = new CompositeDisposable();
+
+        async Task NotifyReceived(Script scriptPubKey, BTCPayNetwork network)
+        {
+            var invoice = await _InvoiceRepository.GetInvoiceIdFromScriptPubKey(scriptPubKey, network.CryptoCode);
+            if (invoice != null)
+            {
+                String address = scriptPubKey.GetDestinationAddress(network.NBitcoinNetwork)?.ToString() ?? scriptPubKey.ToString();
+                Logs.PayServer.LogInformation($"{address} is mapping to invoice {invoice}");
+                _WatchRequests.Add(invoice);
+            }
+        }
+
+        async Task NotifyBlock()
+        {
+            foreach (var invoice in await _InvoiceRepository.GetPendingInvoices())
+            {
+                _WatchRequests.Add(invoice);
+            }
+        }
+
+        private async Task UpdateInvoice(string invoiceId, CancellationToken cancellation)
+        {
+            Dictionary<BTCPayNetwork, KnownState> changes = new Dictionary<BTCPayNetwork, KnownState>();
+            int maxLoop = 5;
+            int loopCount = -1;
+            while (!cancellation.IsCancellationRequested && loopCount < maxLoop)
+            {
+                loopCount++;
+                try
+                {
+                    var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, true).ConfigureAwait(false);
+                    if (invoice == null)
+                        break;
+                    var stateBefore = invoice.Status;
+                    var updateContext = new UpdateInvoiceContext()
+                    {
+                        Invoice = invoice,
+                        KnownStates = changes
+                    };
+                    await UpdateInvoice(updateContext).ConfigureAwait(false);
+                    if (updateContext.Dirty)
+                    {
+                        await _InvoiceRepository.UpdateInvoiceStatus(invoice.Id, invoice.Status, invoice.ExceptionStatus).ConfigureAwait(false);
+                        updateContext.Events.Add(new InvoiceDataChangedEvent() { Status = invoice.Status, ExceptionStatus = invoice.ExceptionStatus, InvoiceId = invoice.Id });
+                    }
+
+                    var changed = stateBefore != invoice.Status;
+
+                    foreach (var evt in updateContext.Events)
+                    {
+                        _EventAggregator.Publish(evt, evt.GetType());
+                    }
+
+                    foreach (var modifiedKnownState in updateContext.ModifiedKnownStates)
+                    {
+                        changes.AddOrReplace(modifiedKnownState.Key, modifiedKnownState.Value);
+                    }
+
+                    if (invoice.Status == "complete" ||
+                       ((invoice.Status == "invalid" || invoice.Status == "expired") && invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
+                    {
+                        if (await _InvoiceRepository.RemovePendingInvoice(invoice.Id).ConfigureAwait(false))
+                            _EventAggregator.Publish<InvoiceStopWatchedEvent>(new InvoiceStopWatchedEvent() { InvoiceId = invoice.Id });
+                        break;
+                    }
+
+                    if (updateContext.Events.Count == 0 || cancellation.IsCancellationRequested)
+                        break;
+                }
+                catch (OperationCanceledException) when (cancellation.IsCancellationRequested)
+                {
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    Logs.PayServer.LogError(ex, "Unhandled error on watching invoice " + invoiceId);
+                    await Task.Delay(10000, cancellation).ConfigureAwait(false);
+                }
+            }
+        }
+
+
+        private async Task UpdateInvoice(UpdateInvoiceContext context)
+        {
+            var invoice = context.Invoice;
+            if (invoice.Status == "new" && invoice.ExpirationTime < DateTimeOffset.UtcNow)
+            {
+                context.MarkDirty();
+                await _InvoiceRepository.UnaffectAddress(invoice.Id);
+
+                context.Events.Add(new InvoiceEvent(invoice, 1004, "invoice_expired"));
+                invoice.Status = "expired";
+            }
+
+            var derivationStrategies = invoice.GetDerivationStrategies(_NetworkProvider).ToArray();
+            var payments = await GetPaymentsWithTransaction(derivationStrategies, invoice);
+            foreach (Task<NetworkCoins> coinsAsync in GetCoinsPerNetwork(context, invoice, derivationStrategies))
+            {
+                var coins = await coinsAsync;
+                if (coins.TimestampedCoins.Length == 0)
+                    continue;
+                bool dirtyAddress = false;
+                if (coins.State != null)
+                    context.ModifiedKnownStates.AddOrReplace(coins.Wallet.Network, coins.State);
+                var alreadyAccounted = new HashSet<OutPoint>(invoice.GetPayments(coins.Wallet.Network).Select(p => p.Outpoint));
+
+                foreach (var coin in coins.TimestampedCoins.Where(c => !alreadyAccounted.Contains(c.Coin.Outpoint)))
+                {
+                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin.DateTime, coin.Coin, coins.Wallet.Network.CryptoCode).ConfigureAwait(false);
+#pragma warning disable CS0618
+                    invoice.Payments.Add(payment);
+#pragma warning restore CS0618
+                    alreadyAccounted.Add(coin.Coin.Outpoint);
+                    context.Events.Add(new InvoiceEvent(invoice, 1002, "invoice_receivedPayment"));
+                    dirtyAddress = true;
+                }
+                if (dirtyAddress)
+                {
+                    payments = await GetPaymentsWithTransaction(derivationStrategies, invoice);
+                }
+                var network = coins.Wallet.Network;
+                var cryptoData = invoice.GetCryptoData(network, _NetworkProvider);
+                var cryptoDataAll = invoice.GetCryptoData(_NetworkProvider);
+                var accounting = cryptoData.Calculate();
+
+                if (invoice.Status == "new" || invoice.Status == "expired")
+                {
+                    var totalPaid = payments.Select(p => p.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+                    if (totalPaid >= accounting.TotalDue)
+                    {
+                        if (invoice.Status == "new")
+                        {
+                            context.Events.Add(new InvoiceEvent(invoice, 1003, "invoice_paidInFull"));
+                            invoice.Status = "paid";
+                            invoice.ExceptionStatus = totalPaid > accounting.TotalDue ? "paidOver" : null;
+                            await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                            context.MarkDirty();
+                        }
+                        else if (invoice.Status == "expired" && invoice.ExceptionStatus != "paidLate")
+                        {
+                            invoice.ExceptionStatus = "paidLate";
+                            context.Events.Add(new InvoiceEvent(invoice, 1009, "invoice_paidAfterExpiration"));
+                            context.MarkDirty();
+                        }
+                    }
+
+                    if (totalPaid < accounting.TotalDue && invoice.GetPayments().Count != 0 && invoice.ExceptionStatus != "paidPartial")
+                    {
+                        invoice.ExceptionStatus = "paidPartial";
+                        context.MarkDirty();
+                        if (dirtyAddress)
+                        {
+                            var address = await coins.Wallet.ReserveAddressAsync(coins.Strategy);
+                            Logs.PayServer.LogInformation("Generate new " + address);
+                            await _InvoiceRepository.NewAddress(invoice.Id, address, network);
+                        }
+                    }
+                }
+
+                if (invoice.Status == "paid")
+                {
+                    IEnumerable<AccountedPaymentEntity> transactions = payments;
+                    if (invoice.SpeedPolicy == SpeedPolicy.HighSpeed)
+                    {
+                        transactions = transactions.Where(t => t.Confirmations >= 1 || !t.Transaction.RBF);
+                    }
+                    else if (invoice.SpeedPolicy == SpeedPolicy.MediumSpeed)
+                    {
+                        transactions = transactions.Where(t => t.Confirmations >= 1);
+                    }
+                    else if (invoice.SpeedPolicy == SpeedPolicy.LowSpeed)
+                    {
+                        transactions = transactions.Where(t => t.Confirmations >= 6);
+                    }
+
+                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+
+                    if (// Is after the monitoring deadline
+                       (invoice.MonitoringExpiration < DateTimeOffset.UtcNow)
+                       &&
+                       // And not enough amount confirmed
+                       (totalConfirmed < accounting.TotalDue))
+                    {
+                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                        context.Events.Add(new InvoiceEvent(invoice, 1013, "invoice_failedToConfirm"));
+                        invoice.Status = "invalid";
+                        context.MarkDirty();
+                    }
+                    else if (totalConfirmed >= accounting.TotalDue)
+                    {
+                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                        context.Events.Add(new InvoiceEvent(invoice, 1005, "invoice_confirmed"));
+                        invoice.Status = "confirmed";
+                        context.MarkDirty();
+                    }
+                }
+
+                if (invoice.Status == "confirmed")
+                {
+                    IEnumerable<AccountedPaymentEntity> transactions = payments;
+                    transactions = transactions.Where(t => t.Confirmations >= 6);
+                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
+                    if (totalConfirmed >= accounting.TotalDue)
+                    {
+                        context.Events.Add(new InvoiceEvent(invoice, 1006, "invoice_completed"));
+                        invoice.Status = "complete";
+                        context.MarkDirty();
+                    }
+                }
+            }
+        }
+
+        private IEnumerable<Task<NetworkCoins>> GetCoinsPerNetwork(UpdateInvoiceContext context, InvoiceEntity invoice, DerivationStrategy[] strategies)
+        {
+            return strategies
+                                .Select(d => (Wallet: _WalletProvider.IsAvailable(d.Network) ? _WalletProvider.GetWallet(d.Network) : null,
+                                              Network: d.Network,
+                                              Strategy: d.DerivationStrategyBase))
+                                .Where(d => d.Wallet != null)
+                                .Select(d => (Network: d.Network,
+                                              Coins: d.Wallet.GetCoins(d.Strategy, context.KnownStates.TryGet(d.Network))))
+                                .Select(async d =>
+                                {
+                                    var coins = await d.Coins;
+                                    // Keep only coins from the invoice
+                                    coins.TimestampedCoins = coins.TimestampedCoins.Where(c => invoice.AvailableAddressHashes.Contains(c.Coin.ScriptPubKey.Hash.ToString() + d.Network.CryptoCode)).ToArray();
+                                    return coins;
+                                })
+                                .ToArray();
+        }
+
+
+        private async Task<IEnumerable<AccountedPaymentEntity>> GetPaymentsWithTransaction(DerivationStrategy[] derivations, InvoiceEntity invoice)
+        {
+            List<PaymentEntity> updatedPaymentEntities = new List<PaymentEntity>();
+            List<AccountedPaymentEntity> accountedPayments = new List<AccountedPaymentEntity>();
+            foreach (var network in derivations.Select(d => d.Network))
+            {
+                var wallet = _WalletProvider.GetWallet(network);
+                if (wallet == null)
+                    continue;
+
+                var transactions = await wallet.GetTransactions(invoice.GetPayments(wallet.Network)
+                    .Select(t => t.Outpoint.Hash)
+                    .ToArray());
+                var conflicts = GetConflicts(transactions.Select(t => t.Value));
+                foreach (var payment in invoice.GetPayments(network))
+                {
+                    if (!transactions.TryGetValue(payment.Outpoint.Hash, out TransactionResult tx))
+                        continue;
+
+                    AccountedPaymentEntity accountedPayment = new AccountedPaymentEntity()
+                    {
+                        Confirmations = tx.Confirmations,
+                        Transaction = tx.Transaction,
+                        Payment = payment
+                    };
+                    var txId = accountedPayment.Transaction.GetHash();
+                    var txConflict = conflicts.GetConflict(txId);
+                    var accounted = txConflict == null || txConflict.IsWinner(txId);
+                    if (accounted != payment.Accounted)
+                    {
+                        updatedPaymentEntities.Add(payment);
+                        payment.Accounted = accounted;
+                    }
+
+                    if (accounted)
+                        accountedPayments.Add(accountedPayment);
+                }
+            }
+            await _InvoiceRepository.UpdatePayments(updatedPaymentEntities);
+            return accountedPayments;
+        }
+
+        class TransactionConflict
+        {
+            public Dictionary<uint256, TransactionResult> Transactions { get; set; } = new Dictionary<uint256, TransactionResult>();
+
+
+            uint256 _Winner;
+            public bool IsWinner(uint256 txId)
+            {
+                if (_Winner == null)
+                {
+                    var confirmed = Transactions.FirstOrDefault(t => t.Value.Confirmations >= 1);
+                    if (!confirmed.Equals(default(KeyValuePair<uint256, TransactionResult>)))
+                    {
+                        _Winner = confirmed.Key;
+                    }
+                    else
+                    {
+                        // Take the most recent (bitcoin node would not forward a conflict without a successfull RBF)
+                        _Winner = Transactions
+                                .OrderByDescending(t => t.Value.Timestamp)
+                                .First()
+                                .Key;
+                    }
+                }
+                return _Winner == txId;
+            }
+        }
+        class TransactionConflicts : List<TransactionConflict>
+        {
+            public TransactionConflicts(IEnumerable<TransactionConflict> collection) : base(collection)
+            {
+
+            }
+
+            public TransactionConflict GetConflict(uint256 txId)
+            {
+                return this.FirstOrDefault(c => c.Transactions.ContainsKey(txId));
+            }
+        }
+        private TransactionConflicts GetConflicts(IEnumerable<TransactionResult> transactions)
+        {
+            Dictionary<OutPoint, TransactionConflict> conflictsByOutpoint = new Dictionary<OutPoint, TransactionConflict>();
+            foreach (var tx in transactions)
+            {
+                var hash = tx.Transaction.GetHash();
+                foreach (var input in tx.Transaction.Inputs)
+                {
+                    TransactionConflict conflict = new TransactionConflict();
+                    if (!conflictsByOutpoint.TryAdd(input.PrevOut, conflict))
+                    {
+                        conflict = conflictsByOutpoint[input.PrevOut];
+                    }
+                    if (!conflict.Transactions.ContainsKey(hash))
+                        conflict.Transactions.Add(hash, tx);
+                }
+            }
+            return new TransactionConflicts(conflictsByOutpoint.Where(c => c.Value.Transactions.Count > 1).Select(c => c.Value));
+        }
+
+        TimeSpan _PollInterval;
+        public TimeSpan PollInterval
+        {
+            get
+            {
+                return _PollInterval;
+            }
+            set
+            {
+                _PollInterval = value;
+            }
+        }
+
+        private async Task Watch(string invoiceId)
+        {
+            if (invoiceId == null)
+                throw new ArgumentNullException(nameof(invoiceId));
+            _WatchRequests.Add(invoiceId);
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            try
+            {
+                var now = DateTimeOffset.UtcNow;
+                if (invoice.ExpirationTime > now)
+                {
+                    await Task.Delay(invoice.ExpirationTime - now, _Cts.Token);
+                    _WatchRequests.Add(invoiceId);
+                }
+            }
+            catch when (_Cts.IsCancellationRequested)
+            { }
+        }
+
+        BlockingCollection<string> _WatchRequests = new BlockingCollection<string>(new ConcurrentQueue<string>());
+
+        Task _Poller;
+        Task _Loop;
+        CancellationTokenSource _Cts;
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+
+            _Poller = StartPoller(_Cts.Token);
+            _Loop = StartLoop(_Cts.Token);
+
+            leases.Add(_EventAggregator.Subscribe<Events.NewBlockEvent>(async b => { await NotifyBlock(); }));
+            leases.Add(_EventAggregator.Subscribe<Events.TxOutReceivedEvent>(async b => { await NotifyReceived(b.ScriptPubKey, b.Network); }));
+            leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async b =>
+            {
+                if (b.Name == "invoice_created")
+                {
+                    await Watch(b.InvoiceId);
+                }
+            }));
+
+            return Task.CompletedTask;
+        }
+
+
+        private async Task StartPoller(CancellationToken cancellation)
+        {
+            try
+            {
+                while (!cancellation.IsCancellationRequested)
+                {
+                    try
+                    {
+                        foreach (var pending in await _InvoiceRepository.GetPendingInvoices())
+                        {
+                            _WatchRequests.Add(pending);
+                        }
+                        await Task.Delay(PollInterval, cancellation);
+                    }
+                    catch (Exception ex) when (!cancellation.IsCancellationRequested)
+                    {
+                        Logs.PayServer.LogError(ex, $"Unhandled exception in InvoiceWatcher poller");
+                        await Task.Delay(PollInterval, cancellation);
+                    }
+                }
+            }
+            catch when (cancellation.IsCancellationRequested) { }
+        }
+
+        async Task StartLoop(CancellationToken cancellation)
+        {
+            Logs.PayServer.LogInformation("Start watching invoices");
+            await Task.Delay(1).ConfigureAwait(false); // Small hack so that the caller does not block on GetConsumingEnumerable
+            ConcurrentDictionary<string, Lazy<Task>> executing = new ConcurrentDictionary<string, Lazy<Task>>();
+            try
+            {
+                // This loop just make sure an invoice will not be updated at the same time by two tasks.
+                // If an update is happening while a request come, then the update is deferred when the executing task is over
+                foreach (var item in _WatchRequests.GetConsumingEnumerable(cancellation))
+                {
+                    var localItem = item;
+                    var toExecute = new Lazy<Task>(async () =>
+                    {
+                        try
+                        {
+                            await UpdateInvoice(localItem, cancellation);
+                        }
+                        finally
+                        {
+                            executing.TryRemove(localItem, out Lazy<Task> unused);
+                        }
+                    }, false);
+                    var executingTask = executing.GetOrAdd(item, toExecute);
+                    executingTask.Value.GetAwaiter(); // Make sure it run
+                    if (executingTask != toExecute)
+                    {
+                        // What was planned can't run for now, rebook it when the executingTask finish
+                        var unused = executingTask.Value.ContinueWith(t => _WatchRequests.Add(localItem));
+                    }
+                }
+            }
+            catch when (cancellation.IsCancellationRequested)
+            {
+            }
+            finally
+            {
+                await Task.WhenAll(executing.Values.Select(v => v.Value).ToArray());
+            }
+            Logs.PayServer.LogInformation("Stop watching invoices");
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            leases.Dispose();
+            _Cts.Cancel();
+            return Task.WhenAll(_Poller, _Loop);
+        }
+    }
+}

BTCPayServer/HostedServices/NBXplorerListener.cs

@@ -0,0 +1,213 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+using BTCPayServer.Services.Invoices;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Hosting;
+using NBXplorer;
+using System.Collections.Concurrent;
+using NBXplorer.DerivationStrategy;
+using BTCPayServer.Events;
+using BTCPayServer.Services;
+
+namespace BTCPayServer.HostedServices
+{
+    public class NBXplorerListener : IHostedService
+    {
+        EventAggregator _Aggregator;
+        ExplorerClientProvider _ExplorerClients;
+        IApplicationLifetime _Lifetime;
+        InvoiceRepository _InvoiceRepository;
+        private TaskCompletionSource<bool> _RunningTask;
+        private CancellationTokenSource _Cts;
+        NBXplorerDashboard _Dashboards;
+        TransactionCacheProvider _TxCache;
+
+        public NBXplorerListener(ExplorerClientProvider explorerClients,
+                                NBXplorerDashboard dashboard,
+                                TransactionCacheProvider cacheProvider,
+                                InvoiceRepository invoiceRepository,
+                                EventAggregator aggregator, IApplicationLifetime lifetime)
+        {
+            PollInterval = TimeSpan.FromMinutes(1.0);
+            _Dashboards = dashboard;
+            _InvoiceRepository = invoiceRepository;
+            _ExplorerClients = explorerClients;
+            _Aggregator = aggregator;
+            _Lifetime = lifetime;
+            _TxCache = cacheProvider;
+        }
+
+        CompositeDisposable leases = new CompositeDisposable();
+        ConcurrentDictionary<string, NotificationSession> _Sessions = new ConcurrentDictionary<string, NotificationSession>();
+        private Timer _ListenPoller;
+
+        TimeSpan _PollInterval;
+        public TimeSpan PollInterval
+        {
+            get
+            {
+                return _PollInterval;
+            }
+            set
+            {
+                _PollInterval = value;
+                if (_ListenPoller != null)
+                {
+                    _ListenPoller.Change(0, (int)value.TotalMilliseconds);
+                }
+            }
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _RunningTask = new TaskCompletionSource<bool>();
+            _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            leases.Add(_Aggregator.Subscribe<Events.NBXplorerStateChangedEvent>(async nbxplorerEvent =>
+            {
+                if (nbxplorerEvent.NewState == NBXplorerState.Ready)
+                {
+                    await Listen(nbxplorerEvent.Network);
+                }
+            }));
+
+            _ListenPoller = new Timer(async s =>
+            {
+                foreach (var nbxplorerState in _Dashboards.GetAll())
+                {
+                    if (nbxplorerState.Status != null && nbxplorerState.Status.IsFullySynched)
+                    {
+                        await Listen(nbxplorerState.Network);
+                    }
+                }
+            }, null, 0, (int)PollInterval.TotalMilliseconds);
+            leases.Add(_ListenPoller);
+
+            leases.Add(_Aggregator.Subscribe<Events.InvoiceEvent>(async inv =>
+            {
+                if (inv.Name == "invoice_created")
+                {
+                    var invoice = await _InvoiceRepository.GetInvoice(null, inv.InvoiceId);
+                    List<Task> listeningDerivations = new List<Task>();
+                    foreach (var notificationSessions in _Sessions)
+                    {
+                        var derivationStrategy = GetStrategy(notificationSessions.Key, invoice);
+                        if (derivationStrategy != null)
+                        {
+                            listeningDerivations.Add(notificationSessions.Value.ListenDerivationSchemesAsync(new[] { derivationStrategy }, _Cts.Token));
+                        }
+                    }
+                    await Task.WhenAll(listeningDerivations.ToArray()).ConfigureAwait(false);
+                }
+            }));
+            return Task.CompletedTask;
+        }
+
+        private async Task Listen(BTCPayNetwork network)
+        {
+            bool cleanup = false;
+            try
+            {
+                if (_Sessions.ContainsKey(network.CryptoCode))
+                    return;
+                var client = _ExplorerClients.GetExplorerClient(network);
+                if (client == null)
+                    return;
+                if (_Cts.IsCancellationRequested)
+                    return;
+                var session = await client.CreateNotificationSessionAsync(_Cts.Token).ConfigureAwait(false);
+                if (!_Sessions.TryAdd(network.CryptoCode, session))
+                {
+                    await session.DisposeAsync();
+                    return;
+                }
+                cleanup = true;
+                using (session)
+                {
+                    await session.ListenNewBlockAsync(_Cts.Token).ConfigureAwait(false);
+                    await session.ListenDerivationSchemesAsync((await GetStrategies(network)).ToArray(), _Cts.Token).ConfigureAwait(false);
+                    Logs.PayServer.LogInformation($"Connected to WebSocket of NBXplorer ({network.CryptoCode})");
+                    while (!_Cts.IsCancellationRequested)
+                    {
+                        var newEvent = await session.NextEventAsync(_Cts.Token).ConfigureAwait(false);
+                        switch (newEvent)
+                        {
+                            case NBXplorer.Models.NewBlockEvent evt:
+                                _TxCache.GetTransactionCache(network).NewBlock(evt.Hash, evt.PreviousBlockHash);
+                                _Aggregator.Publish(new Events.NewBlockEvent() { CryptoCode = evt.CryptoCode });
+                                break;
+                            case NBXplorer.Models.NewTransactionEvent evt:
+                                foreach (var txout in evt.Outputs)
+                                {
+                                    _TxCache.GetTransactionCache(network).AddToCache(evt.TransactionData);
+                                    _Aggregator.Publish(new Events.TxOutReceivedEvent()
+                                    {
+                                        Network = network,
+                                        ScriptPubKey = txout.ScriptPubKey
+                                    });
+                                }
+                                break;
+                            default:
+                                Logs.PayServer.LogWarning("Received unknown message from NBXplorer");
+                                break;
+                        }
+                    }
+                }
+            }
+            catch when (_Cts.IsCancellationRequested) { }
+            catch (Exception ex)
+            {
+                Logs.PayServer.LogError(ex, $"Error while connecting to WebSocket of NBXplorer ({network.CryptoCode})");
+            }
+            finally
+            {
+                if (cleanup)
+                {
+                    Logs.PayServer.LogInformation($"Disconnected from WebSocket of NBXplorer ({network.CryptoCode})");
+                    _Sessions.TryRemove(network.CryptoCode, out NotificationSession unused);
+                    if (_Sessions.Count == 0 && _Cts.IsCancellationRequested)
+                    {
+                        _RunningTask.TrySetResult(true);
+                    }
+                }
+            }
+        }
+
+        private async Task<List<DerivationStrategyBase>> GetStrategies(BTCPayNetwork network)
+        {
+            List<DerivationStrategyBase> strategies = new List<DerivationStrategyBase>();
+            foreach (var invoiceId in await _InvoiceRepository.GetPendingInvoices())
+            {
+                var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+                var strategy = GetStrategy(network.CryptoCode, invoice);
+                if (strategy != null)
+                    strategies.Add(strategy);
+            }
+
+            return strategies;
+        }
+
+        private DerivationStrategyBase GetStrategy(string cryptoCode, InvoiceEntity invoice)
+        {
+            foreach (var derivationStrategy in invoice.GetDerivationStrategies(_ExplorerClients.NetworkProviders))
+            {
+                if (derivationStrategy.Network.CryptoCode == cryptoCode)
+                {
+                    return derivationStrategy.DerivationStrategyBase;
+                }
+            }
+            return null;
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            leases.Dispose();
+            _Cts.Cancel();
+            return Task.WhenAny(_RunningTask.Task, Task.Delay(-1, cancellationToken));
+        }
+    }
+}

BTCPayServer/HostedServices/NBXplorerWaiter.cs

@@ -0,0 +1,222 @@
+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.HostedServices
+{
+    public enum NBXplorerState
+    {
+        NotConnected,
+        Synching,
+        Ready
+    }
+
+    public class NBXplorerDashboard
+    {
+        public class NBXplorerSummary
+        {
+            public BTCPayNetwork Network { get; set; }
+            public NBXplorerState State { get; set; }
+            public StatusResult Status { get; set; }
+            public string Error { get; set; }
+        }
+        ConcurrentDictionary<string, NBXplorerSummary> _Summaries = new ConcurrentDictionary<string, NBXplorerSummary>();
+        public void Publish(BTCPayNetwork network, NBXplorerState state, StatusResult status, string error)
+        {
+            var summary = new NBXplorerSummary() { Network = network, State = state, Status = status, Error = error };
+            _Summaries.AddOrUpdate(network.CryptoCode, summary, (k, v) => summary);
+        }
+
+        public bool IsFullySynched()
+        {
+            return _Summaries.All(s => s.Value.Status != null && s.Value.Status.IsFullySynched);
+        }
+
+        public bool IsFullySynched(string cryptoCode)
+        {
+            return _Summaries.Any(s => s.Key.Equals(cryptoCode, StringComparison.OrdinalIgnoreCase) && s.Value.Status != null && s.Value.Status.IsFullySynched);
+        }
+
+        public IEnumerable<NBXplorerSummary> GetAll()
+        {
+            return _Summaries.Values;
+        }
+    }
+
+    public class NBXplorerWaiters : IHostedService
+    {
+        List<NBXplorerWaiter> _Waiters = new List<NBXplorerWaiter>();
+        public NBXplorerWaiters(NBXplorerDashboard dashboard, ExplorerClientProvider explorerClientProvider, EventAggregator eventAggregator)
+        {
+            foreach (var explorer in explorerClientProvider.GetAll())
+            {
+                _Waiters.Add(new NBXplorerWaiter(dashboard, explorer.Item1, explorer.Item2, eventAggregator));
+            }
+        }
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            return Task.WhenAll(_Waiters.Select(w => w.StartAsync(cancellationToken)).ToArray());
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            return Task.WhenAll(_Waiters.Select(w => w.StopAsync(cancellationToken)).ToArray());
+        }
+    }
+
+    public class NBXplorerWaiter : IHostedService
+    {
+
+        public NBXplorerWaiter(NBXplorerDashboard dashboard, BTCPayNetwork network, ExplorerClient client, EventAggregator aggregator)
+        {
+            _Network = network;
+            _Client = client;
+            _Aggregator = aggregator;
+            _Dashboard = dashboard;
+        }
+
+        NBXplorerDashboard _Dashboard;
+        BTCPayNetwork _Network;
+        EventAggregator _Aggregator;
+        ExplorerClient _Client;
+
+        CancellationTokenSource _Cts;
+        Task _Loop;
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            _Loop = StartLoop(_Cts.Token);
+            return Task.CompletedTask;
+        }
+
+        private async Task StartLoop(CancellationToken cancellation)
+        {
+            Logs.PayServer.LogInformation($"Starting listening NBXplorer ({_Network.CryptoCode})");
+            try
+            {
+                while (!cancellation.IsCancellationRequested)
+                {
+                    try
+                    {
+                        while (await StepAsync(cancellation))
+                        {
+
+                        }
+                        await Task.Delay(PollInterval, cancellation);
+                    }
+                    catch (Exception ex) when (!cancellation.IsCancellationRequested)
+                    {
+                        Logs.PayServer.LogError(ex, $"Unhandled exception in NBXplorerWaiter ({_Network.CryptoCode})");
+                        await Task.Delay(TimeSpan.FromSeconds(10), cancellation);
+                    }
+                }
+            }
+            catch when (cancellation.IsCancellationRequested) { }
+        }
+
+        private async Task<bool> StepAsync(CancellationToken cancellation)
+        {
+            var oldState = State;
+            string error = null;
+            StatusResult status = null;
+            try
+            {
+                switch (State)
+                {
+                    case NBXplorerState.NotConnected:
+                        status = await _Client.GetStatusAsync(cancellation);
+                        if (status != null)
+                        {
+                            if (status.IsFullySynched)
+                            {
+                                State = NBXplorerState.Ready;
+                            }
+                            else
+                            {
+                                State = NBXplorerState.Synching;
+                            }
+                        }
+                        break;
+                    case NBXplorerState.Synching:
+                        status = await _Client.GetStatusAsync(cancellation);
+                        if (status == null)
+                        {
+                            State = NBXplorerState.NotConnected;
+                        }
+                        else if (status.IsFullySynched)
+                        {
+                            State = NBXplorerState.Ready;
+                        }
+                        break;
+                    case NBXplorerState.Ready:
+                        status = await _Client.GetStatusAsync(cancellation);
+                        if (status == null)
+                        {
+                            State = NBXplorerState.NotConnected;
+                        }
+                        else if (!status.IsFullySynched)
+                        {
+                            State = NBXplorerState.Synching;
+                        }
+                        break;
+                }
+
+            }
+            catch (Exception ex) when (!cancellation.IsCancellationRequested)
+            {
+                error = ex.Message;
+            }
+
+
+            if(status == null && error == null)
+                error = $"{_Network.CryptoCode}: NBXplorer does not support this cryptocurrency";
+
+            if(status != null && error == null)
+            {
+                if(status.ChainType != _Network.NBXplorerNetwork.DefaultSettings.ChainType)
+                    error = $"{_Network.CryptoCode}: NBXplorer is on a different ChainType (actual: {status.ChainType}, expected: {_Network.NBXplorerNetwork.DefaultSettings.ChainType})";
+            }
+
+            if (error != null)
+            {
+                State = NBXplorerState.NotConnected;
+                status = null;
+                _Aggregator.Publish(new NBXplorerErrorEvent(_Network, error));
+            }
+
+            if (oldState != State)
+            {
+                if (State == NBXplorerState.Synching)
+                {
+                    PollInterval = TimeSpan.FromSeconds(10);
+                }
+                else
+                {
+                    PollInterval = TimeSpan.FromMinutes(1);
+                }
+                _Aggregator.Publish(new NBXplorerStateChangedEvent(_Network, oldState, State));
+            }
+            _Dashboard.Publish(_Network, State, status, error);
+            return oldState != State;
+        }
+
+        public TimeSpan PollInterval { get; set; } = TimeSpan.FromMinutes(1.0);
+
+        public NBXplorerState State { get; private set; }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            _Cts.Cancel();
+            return _Loop;
+        }
+    }
+}

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -36,6 +36,7 @@ using BTCPayServer.Services.Wallets;
 using BTCPayServer.Authentication;
 using Microsoft.Extensions.Caching.Memory;
 using BTCPayServer.Logging;
+using BTCPayServer.HostedServices;
 
 namespace BTCPayServer.Hosting
 {
@@ -102,7 +103,7 @@ namespace BTCPayServer.Hosting
                 var dbpath = Path.Combine(opts.DataDir, "InvoiceDB");
                 if (!Directory.Exists(dbpath))
                     Directory.CreateDirectory(dbpath);
-                return new InvoiceRepository(dbContext, dbpath, opts.Network);
+                return new InvoiceRepository(dbContext, dbpath);
             });
             services.AddSingleton<BTCPayServerEnvironment>();
             services.TryAddSingleton<TokenRepository>();
@@ -128,51 +129,39 @@ namespace BTCPayServer.Hosting
             services.TryAddSingleton<BTCPayNetworkProvider>(o => 
             {
                 var opts = o.GetRequiredService<BTCPayServerOptions>();
-                return new BTCPayNetworkProvider(opts.Network);
+                return new BTCPayNetworkProvider(opts.ChainType);
             });
 
+            services.TryAddSingleton<NBXplorerDashboard>();
             services.TryAddSingleton<StoreRepository>();
-            services.TryAddSingleton<BTCPayWallet>();
+            services.TryAddSingleton<BTCPayWalletProvider>();
             services.TryAddSingleton<CurrencyNameTable>();
-            services.TryAddSingleton<IFeeProviderFactory>(o => new NBXplorerFeeProviderFactory(o.GetRequiredService<ExplorerClient>())
+            services.TryAddSingleton<IFeeProviderFactory>(o => new NBXplorerFeeProviderFactory(o.GetRequiredService<ExplorerClientProvider>())
             {
                 Fallback = new FeeRate(100, 1),
                 BlockTarget = 20
             });
 
-            services.TryAddSingleton<NBXplorerWaiterAccessor>();
-            services.AddSingleton<IHostedService, NBXplorerWaiter>();
-            services.TryAddSingleton<ExplorerClient>(o =>
-            {
-                var opts = o.GetRequiredService<BTCPayServerOptions>();
-                var explorer = new ExplorerClient(opts.Network, opts.Explorer);
-                if (!explorer.SetCookieAuth(opts.CookieFile))
-                    explorer.SetNoAuth();
-                return explorer;
-            });
+            services.AddSingleton<TransactionCacheProvider>();
+
+            services.AddSingleton<IHostedService, NBXplorerWaiters>();
+            services.AddSingleton<IHostedService, NBXplorerListener>();
+            services.AddSingleton<IHostedService, InvoiceNotificationManager>();
+            services.AddSingleton<IHostedService, InvoiceWatcher>();
+
+            services.TryAddSingleton<ExplorerClientProvider>();
             services.TryAddSingleton<Bitpay>(o =>
             {
-                if (o.GetRequiredService<BTCPayServerOptions>().Network == Network.Main)
+                if (o.GetRequiredService<BTCPayServerOptions>().ChainType == ChainType.Main)
                     return new Bitpay(new Key(), new Uri("https://bitpay.com/"));
                 else
                     return new Bitpay(new Key(), new Uri("https://test.bitpay.com/"));
             });
-            services.TryAddSingleton<IRateProvider>(o =>
-            {
-                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.AddSingleton<IHostedService, InvoiceNotificationManager>();
+            services.TryAddSingleton<IRateProviderFactory, CachedDefaultRateProviderFactory>();
 
-            services.TryAddSingleton<InvoiceWatcherAccessor>();
-            services.AddSingleton<IHostedService, InvoiceWatcher>();
-            services.TryAddSingleton<Initializer>();
             services.TryAddScoped<IHttpContextAccessor, HttpContextAccessor>();
             services.TryAddSingleton<IAuthorizationHandler, OwnStoreHandler>();
             services.AddTransient<AccessTokenController>();
-            services.AddTransient<CallbackController>();
             services.AddTransient<InvoiceController>();
             // Add application services.
             services.AddTransient<IEmailSender, EmailSender>();
@@ -204,10 +193,6 @@ namespace BTCPayServer.Hosting
                 });
             }
 
-
-
-            var initialize = app.ApplicationServices.GetService<Initializer>();
-            initialize.Init();
             app.UseMiddleware<BTCPayMiddleware>();
             return app;
         }
@@ -222,11 +207,9 @@ namespace BTCPayServer.Hosting
                     act();
                     return;
                 }
-                catch
+                catch when(!cts.IsCancellationRequested)
                 {
-                    if (cts.IsCancellationRequested)
-                        throw;
-                    Thread.Sleep(1000);
+                    Thread.Sleep(100);
                 }
             }
         }

BTCPayServer/Hosting/BTCpayMiddleware.cs

@@ -99,39 +99,73 @@ namespace BTCPayServer.Hosting
 
         private void RewriteHostIfNeeded(HttpContext httpContext)
         {
+            string reverseProxyScheme = null;
+            if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Proto", out StringValues proto))
+            {
+                var scheme = proto.SingleOrDefault();
+                if (scheme != null)
+                {
+                    reverseProxyScheme = scheme;
+                }
+            }
+
+            ushort? reverseProxyPort = null;
+            if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Port", out StringValues port))
+            {
+                var portString = port.SingleOrDefault();
+                if (portString != null && ushort.TryParse(portString, out ushort pp))
+                {
+                    reverseProxyPort = pp;
+                }
+            }
+
             // 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 (reverseProxyScheme != null && _Options.ExternalUrl.Scheme != reverseProxyScheme)
+                {
+                    if (reverseProxyScheme == "http" && _Options.ExternalUrl.Scheme == "https")
+                        Logs.PayServer.LogWarning($"BTCPay ExternalUrl setting expected to use scheme '{_Options.ExternalUrl.Scheme}' externally, but the reverse proxy uses scheme '{reverseProxyScheme}'");
+                    httpContext.Request.Scheme = reverseProxyScheme;
+                }
+                else
+                { 
+                    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);
+                {
+                    if (reverseProxyPort != null && _Options.ExternalUrl.Port != reverseProxyPort.Value)
+                    {
+                        Logs.PayServer.LogWarning($"BTCPay ExternalUrl setting expected to use port '{_Options.ExternalUrl.Port}' externally, but the reverse proxy uses port '{reverseProxyPort.Value}'");
+                        httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, reverseProxyPort.Value);
+                    }
+                    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))
+                if (reverseProxyScheme != null)
                 {
-                    var scheme = proto.SingleOrDefault();
-                    if (scheme != null)
-                    {
-                        httpContext.Request.Scheme = scheme;
-                        if (scheme == "http")
-                            p = 80;
-                        if (scheme == "https")
-                            p = 443;
-                    }
+                    httpContext.Request.Scheme = reverseProxyScheme;
+                    if (reverseProxyScheme == "http")
+                        p = 80;
+                    if (reverseProxyScheme == "https")
+                        p = 443;
                 }
-                if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Port", out StringValues port))
+
+
+                if (reverseProxyPort != null)
                 {
-                    var portString = port.SingleOrDefault();
-                    if (portString != null && ushort.TryParse(portString, out ushort pp))
-                    {
-                        p = pp;
-                    }
+                    p = reverseProxyPort.Value;
                 }
+
                 if (p.HasValue)
                 {
                     bool isDefault = httpContext.Request.Scheme == "http" && p.Value == 80;

BTCPayServer/Initializer.cs

@@ -1,45 +0,0 @@
-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/ConsoleLogger.cs

@@ -12,7 +12,11 @@ namespace BTCPayServer.Logging
 {
     public class CustomConsoleLogProvider : ILoggerProvider
     {
-        ConsoleLoggerProcessor _Processor = new ConsoleLoggerProcessor();
+        ConsoleLoggerProcessor _Processor;
+        public CustomConsoleLogProvider(ConsoleLoggerProcessor processor)
+        {
+            _Processor = processor;
+        }
         public ILogger CreateLogger(string categoryName)
         {
             return new CustomConsoleLogger(categoryName, (a, b) => true, false, _Processor);

BTCPayServer/Migrations/20171012020112_PendingInvoices.cs

@@ -8,7 +8,7 @@ namespace BTCPayServer.Migrations
     {
         protected override void Up(MigrationBuilder migrationBuilder)
         {
-            if (SupportDropColumn(migrationBuilder.ActiveProvider))
+            if (this.SupportDropColumn(migrationBuilder.ActiveProvider))
             {
                 migrationBuilder.DropColumn(
                     name: "Name",
@@ -30,11 +30,6 @@ namespace BTCPayServer.Migrations
                 });
         }
 
-        private bool SupportDropColumn(string activeProvider)
-        {
-            return activeProvider != "Microsoft.EntityFrameworkCore.Sqlite";
-        }
-
         protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropTable(

BTCPayServer/Migrations/20180106095215_DerivationStrategies.Designer.cs

@@ -0,0 +1,483 @@
+// <auto-generated />
+using BTCPayServer.Data;
+using BTCPayServer.Services.Invoices;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Storage.Internal;
+using System;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180106095215_DerivationStrategies")]
+    partial class DerivationStrategies
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.1-rtm-125");
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.Property<string>("Address")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTimeOffset?>("CreatedTime");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Address");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("AddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("Address");
+
+                    b.Property<DateTimeOffset>("Assigned");
+
+                    b.Property<string>("CryptoCode");
+
+                    b.Property<DateTimeOffset?>("UnAssigned");
+
+                    b.HasKey("InvoiceDataId", "Address");
+
+                    b.ToTable("HistoricalAddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("CustomerEmail");
+
+                    b.Property<string>("ExceptionStatus");
+
+                    b.Property<string>("ItemCode");
+
+                    b.Property<string>("OrderId");
+
+                    b.Property<string>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Invoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<DateTimeOffset>("PairingTime");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SIN");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PairedSINData");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairingCodeData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("DateCreated");
+
+                    b.Property<DateTimeOffset>("Expiration");
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("TokenValue");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PairingCodes");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Accounted");
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("Payments");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PendingInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("RefundAddresses");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.SettingData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoreData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("DerivationStrategies");
+
+                    b.Property<string>("DerivationStrategy");
+
+                    b.Property<int>("SpeedPolicy");
+
+                    b.Property<byte[]>("StoreBlob");
+
+                    b.Property<byte[]>("StoreCertificate");
+
+                    b.Property<string>("StoreName");
+
+                    b.Property<string>("StoreWebsite");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Stores");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("Role");
+
+                    b.HasKey("ApplicationUserId", "StoreDataId");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("UserStore");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<bool>("RequiresEmailConfirmation");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("AddressInvoices")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData")
+                        .WithMany("HistoricalAddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany()
+                        .HasForeignKey("StoreDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Payments")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("RefundAddresses")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("UserStores")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("UserStores")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

BTCPayServer/Migrations/20180106095215_DerivationStrategies.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class DerivationStrategies : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "DerivationStrategies",
+                table: "Stores",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "DerivationStrategies",
+                table: "Stores");
+        }
+    }
+}

BTCPayServer/Migrations/20180109021122_defaultcrypto.Designer.cs

@@ -0,0 +1,485 @@
+// <auto-generated />
+using BTCPayServer.Data;
+using BTCPayServer.Services.Invoices;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Storage.Internal;
+using System;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180109021122_defaultcrypto")]
+    partial class defaultcrypto
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.1-rtm-125");
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.Property<string>("Address")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTimeOffset?>("CreatedTime");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Address");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("AddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("Address");
+
+                    b.Property<DateTimeOffset>("Assigned");
+
+                    b.Property<string>("CryptoCode");
+
+                    b.Property<DateTimeOffset?>("UnAssigned");
+
+                    b.HasKey("InvoiceDataId", "Address");
+
+                    b.ToTable("HistoricalAddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("CustomerEmail");
+
+                    b.Property<string>("ExceptionStatus");
+
+                    b.Property<string>("ItemCode");
+
+                    b.Property<string>("OrderId");
+
+                    b.Property<string>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Invoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<DateTimeOffset>("PairingTime");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SIN");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PairedSINData");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairingCodeData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("DateCreated");
+
+                    b.Property<DateTimeOffset>("Expiration");
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("TokenValue");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PairingCodes");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Accounted");
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("Payments");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PendingInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("RefundAddresses");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.SettingData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoreData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("DefaultCrypto");
+
+                    b.Property<string>("DerivationStrategies");
+
+                    b.Property<string>("DerivationStrategy");
+
+                    b.Property<int>("SpeedPolicy");
+
+                    b.Property<byte[]>("StoreBlob");
+
+                    b.Property<byte[]>("StoreCertificate");
+
+                    b.Property<string>("StoreName");
+
+                    b.Property<string>("StoreWebsite");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Stores");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("Role");
+
+                    b.HasKey("ApplicationUserId", "StoreDataId");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("UserStore");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<bool>("RequiresEmailConfirmation");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("AddressInvoices")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData")
+                        .WithMany("HistoricalAddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany()
+                        .HasForeignKey("StoreDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Payments")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("RefundAddresses")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("UserStores")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("UserStores")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

BTCPayServer/Migrations/20180109021122_defaultcrypto.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class defaultcrypto : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "DefaultCrypto",
+                table: "Stores",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "DefaultCrypto",
+                table: "Stores");
+        }
+    }
+}

BTCPayServer/Migrations/20180114123253_events.Designer.cs

@@ -0,0 +1,508 @@
+// <auto-generated />
+using BTCPayServer.Data;
+using BTCPayServer.Services.Invoices;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Storage.Internal;
+using System;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180114123253_events")]
+    partial class events
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.1-rtm-125");
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.Property<string>("Address")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTimeOffset?>("CreatedTime");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Address");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("AddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("Address");
+
+                    b.Property<DateTimeOffset>("Assigned");
+
+                    b.Property<string>("CryptoCode");
+
+                    b.Property<DateTimeOffset?>("UnAssigned");
+
+                    b.HasKey("InvoiceDataId", "Address");
+
+                    b.ToTable("HistoricalAddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("CustomerEmail");
+
+                    b.Property<string>("ExceptionStatus");
+
+                    b.Property<string>("ItemCode");
+
+                    b.Property<string>("OrderId");
+
+                    b.Property<string>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Invoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("UniqueId");
+
+                    b.Property<string>("Message");
+
+                    b.Property<DateTimeOffset>("Timestamp");
+
+                    b.HasKey("InvoiceDataId", "UniqueId");
+
+                    b.ToTable("InvoiceEvents");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<DateTimeOffset>("PairingTime");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SIN");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PairedSINData");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairingCodeData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("DateCreated");
+
+                    b.Property<DateTimeOffset>("Expiration");
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("TokenValue");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PairingCodes");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Accounted");
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("Payments");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PendingInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("RefundAddresses");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.SettingData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoreData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("DefaultCrypto");
+
+                    b.Property<string>("DerivationStrategies");
+
+                    b.Property<string>("DerivationStrategy");
+
+                    b.Property<int>("SpeedPolicy");
+
+                    b.Property<byte[]>("StoreBlob");
+
+                    b.Property<byte[]>("StoreCertificate");
+
+                    b.Property<string>("StoreName");
+
+                    b.Property<string>("StoreWebsite");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Stores");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("Role");
+
+                    b.HasKey("ApplicationUserId", "StoreDataId");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("UserStore");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<bool>("RequiresEmailConfirmation");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("AddressInvoices")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData")
+                        .WithMany("HistoricalAddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany()
+                        .HasForeignKey("StoreDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData")
+                        .WithMany("Events")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Payments")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("RefundAddresses")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("UserStores")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("UserStores")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

BTCPayServer/Migrations/20180114123253_events.cs

@@ -0,0 +1,38 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class events : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "InvoiceEvents",
+                columns: table => new
+                {
+                    InvoiceDataId = table.Column<string>(nullable: false),
+                    UniqueId = table.Column<string>(nullable: false),
+                    Message = table.Column<string>(nullable: true),
+                    Timestamp = table.Column<DateTimeOffset>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_InvoiceEvents", x => new { x.InvoiceDataId, x.UniqueId });
+                    table.ForeignKey(
+                        name: "FK_InvoiceEvents_Invoices_InvoiceDataId",
+                        column: x => x.InvoiceDataId,
+                        principalTable: "Invoices",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "InvoiceEvents");
+        }
+    }
+}

BTCPayServer/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -81,6 +81,21 @@ namespace BTCPayServer.Migrations
                     b.ToTable("Invoices");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("UniqueId");
+
+                    b.Property<string>("Message");
+
+                    b.Property<DateTimeOffset>("Timestamp");
+
+                    b.HasKey("InvoiceDataId", "UniqueId");
+
+                    b.ToTable("InvoiceEvents");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
                 {
                     b.Property<string>("Id")
@@ -190,6 +205,10 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("Id")
                         .ValueGeneratedOnAdd();
 
+                    b.Property<string>("DefaultCrypto");
+
+                    b.Property<string>("DerivationStrategies");
+
                     b.Property<string>("DerivationStrategy");
 
                     b.Property<int>("SpeedPolicy");
@@ -403,6 +422,14 @@ namespace BTCPayServer.Migrations
                         .HasForeignKey("StoreDataId");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData")
+                        .WithMany("Events")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
                 {
                     b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")

BTCPayServer/Models/InvoiceResponse.cs

@@ -37,81 +37,6 @@ namespace BTCPayServer.Models
         }
     }
 
-    public class InvoiceCryptoInfo
-    {
-        [JsonProperty("cryptoCode")]
-        public string CryptoCode { get; set; }
-
-        [JsonProperty("rate")]
-        public decimal Rate { get; set; }
-
-        //"exRates":{"USD":4320.02}
-        [JsonProperty("exRates")]
-        public Dictionary<string, double> ExRates
-        {
-            get; set;
-        }
-
-        //"btcPaid":"0.000000"
-        [JsonProperty("paid")]
-        public string Paid
-        {
-            get; set;
-        }
-
-        //"btcPrice":"0.001157"
-        [JsonProperty("price")]
-        public string Price
-        {
-            get; set;
-        }
-
-        //"btcDue":"0.001160"
-        /// <summary>
-        /// Amount of crypto remaining to pay this invoice
-        /// </summary>
-        [JsonProperty("due")]
-        public string Due
-        {
-            get; set;
-        }
-
-        [JsonProperty("paymentUrls")]
-        public NBitpayClient.InvoicePaymentUrls PaymentUrls
-        {
-            get; set;
-        }
-
-        [JsonProperty("address")]
-        public string Address { get; set; }
-        [JsonProperty("url")]
-        public string Url { get; set; }
-
-        /// <summary>
-        /// Total amount of this invoice
-        /// </summary>
-        [JsonProperty("totalDue")]
-        public string TotalDue { get; set; }
-
-        /// <summary>
-        /// Total amount of network fee to pay to the invoice
-        /// </summary>
-        [JsonProperty("networkFee")]
-        public string NetworkFee { get; set; }
-
-        /// <summary>
-        /// Number of transactions required to pay
-        /// </summary>
-        [JsonProperty("txCount")]
-        public int TxCount { get; set; }
-
-        /// <summary>
-        /// Total amount of the invoice paid in this crypto
-        /// </summary>
-        [JsonProperty("cryptoPaid")]
-        public Money CryptoPaid { get; set; }
-    }
-
     //{"facade":"pos/invoice","data":{,}}
     public class InvoiceResponse
     {
@@ -151,7 +76,7 @@ namespace BTCPayServer.Models
         }
 
         [JsonProperty("cryptoInfo")]
-        public List<InvoiceCryptoInfo> CryptoInfo { get; set; }
+        public List<NBitpayClient.InvoiceCryptoInfo> CryptoInfo { get; set; }
 
         //"price":5
         [JsonProperty("price")]

BTCPayServer/Models/InvoicingModels/InvoiceDetailsModel.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Data;
 using BTCPayServer.Services.Invoices;
 using NBitcoin;
 
@@ -9,8 +10,18 @@ namespace BTCPayServer.Models.InvoicingModels
 {
     public class InvoiceDetailsModel
     {
+        public class CryptoPayment
+        {
+            public string CryptoCode { get; set; }
+            public string Due { get; set; }
+            public string Paid { get; set; }
+            public string Address { get; internal set; }
+            public string Rate { get; internal set; }
+            public string PaymentUrl { get; internal set; }
+        }
         public class Payment
         {
+            public string CryptoCode { get; set; }
             public int Confirmations
             {
                 get; set;
@@ -37,6 +48,8 @@ namespace BTCPayServer.Models.InvoicingModels
                 get;
                 set;
             }
+
+            public bool Replaced { get; set; }
         }
 
         public string StatusMessage
@@ -48,16 +61,18 @@ namespace BTCPayServer.Models.InvoicingModels
             get; set;
         }
 
-        public List<Payment> Payments
+        public List<CryptoPayment> CryptoPayments
         {
             get; set;
-        } = new List<Payment>();
+        } = new List<CryptoPayment>();
+
+        public List<Payment> Payments { get; set; } = new List<Payment>();
 
         public string Status
         {
             get; set;
         }
-
+        public string StatusException { get; set; }
         public DateTimeOffset CreatedDate
         {
             get; set;
@@ -82,6 +97,8 @@ namespace BTCPayServer.Models.InvoicingModels
             get;
             set;
         }
+
+        public string TransactionSpeed { get; set; }
         public object StoreName
         {
             get;
@@ -92,55 +109,25 @@ namespace BTCPayServer.Models.InvoicingModels
             get;
             set;
         }
-        public decimal Rate
-        {
-            get;
-            internal set;
-        }
         public string NotificationUrl
         {
             get;
             internal set;
         }
+
+        public string RedirectUrl { get; set; }
         public string Fiat
         {
             get;
             set;
         }
-        public string BTC
-        {
-            get;
-            set;
-        }
-        public string BTCDue
-        {
-            get;
-            set;
-        }
-        public string BTCPaid
-        {
-            get;
-            internal set;
-        }
-        public String NetworkFee
-        {
-            get;
-            internal set;
-        }
         public ProductInformation ProductInformation
         {
             get;
             internal set;
         }
-        public BitcoinAddress BitcoinAddress
-        {
-            get;
-            internal set;
-        }
-        public string PaymentUrl
-        {
-            get;
-            set;
-        }
+        public HistoricalAddressInvoiceData[] Addresses { get; set; }
+        public DateTimeOffset MonitoringDate { get; internal set; }
+        public List<Data.InvoiceEventData> Events { get; internal set; }
     }
 }

BTCPayServer/Models/InvoicingModels/PaymentModel.cs

@@ -7,6 +7,14 @@ namespace BTCPayServer.Models.InvoicingModels
 {
     public class PaymentModel
     {
+        public class AvailableCrypto
+        {
+            public string CryptoCode { get; set; }
+            public string CryptoImage { get; set; }
+            public string Link { get; set; }
+        }
+        public List<AvailableCrypto> AvailableCryptos { get; set; } = new List<AvailableCrypto>();
+        public string CryptoCode { get; set; }
         public string ServerUrl { get; set; }
         public string InvoiceId { get; set; }
         public string BtcAddress { get; set; }
@@ -22,14 +30,15 @@ namespace BTCPayServer.Models.InvoicingModels
         public string ItemDesc { get; set; }
         public string TimeLeft { get; set; }
         public string Rate { get; set; }
-        public string BtcAmount { get; set; }
-        public string TxFees { get; set; }
+        public string OrderAmount { get; set; }
         public string InvoiceBitcoinUrl { get; set; }
-        public string BtcTotalDue { get; set; }
         public int TxCount { get; set; }
         public string BtcPaid { get; set; }
         public string StoreEmail { get; set; }
 
         public string OrderId { get; set; }
+        public string CryptoImage { get; set; }
+        public string NetworkFeeDescription { get; internal set; }
+        public int MaxTimeMinutes { get; internal set; }
     }
 }

BTCPayServer/Models/StoreViewModels/DerivationSchemeViewModel.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace BTCPayServer.Models.StoreViewModels
+{
+    public class DerivationSchemeViewModel
+    {
+        class Format
+        {
+            public string Name { get; set; }
+            public string Value { get; set; }
+        }
+        public DerivationSchemeViewModel()
+        {
+            var btcPay = new Format { Name = "BTCPay", Value = "BTCPay" };
+            DerivationSchemeFormat = btcPay.Value;
+            DerivationSchemeFormats = new SelectList(new Format[]
+            {
+                btcPay,
+                new Format { Name = "Electrum", Value = "Electrum" },
+            }, nameof(btcPay.Value), nameof(btcPay.Name), btcPay);
+        }
+        public string DerivationScheme
+        {
+            get; set;
+        }
+
+        public List<(string KeyPath, string Address)> AddressSamples
+        {
+            get; set;
+        } = new List<(string KeyPath, string Address)>();
+
+        [Display(Name = "Derivation Scheme format")]
+        public string DerivationSchemeFormat
+        {
+            get;
+            set;
+        }
+
+        [Display(Name = "Crypto currency")]
+        public string CryptoCurrency
+        {
+            get;
+            set;
+        }
+
+        public SelectList CryptoCurrencies { get; set; }
+        public SelectList DerivationSchemeFormats { get; set; }
+
+        
+        public void SetCryptoCurrencies(ExplorerClientProvider explorerProvider, string selectedScheme)
+        {
+            var choices = explorerProvider.GetAll().Select(o => new Format() { Name = o.Item1.CryptoCode, Value = o.Item1.CryptoCode }).ToArray();
+            var chosen = choices.FirstOrDefault(f => f.Name == selectedScheme) ?? choices.FirstOrDefault();
+            CryptoCurrencies = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
+            CryptoCurrency = chosen.Name;
+        }
+    }
+}

BTCPayServer/Models/StoreViewModels/StoreViewModel.cs

@@ -11,6 +11,11 @@ namespace BTCPayServer.Models.StoreViewModels
 {
     public class StoreViewModel
     {
+        public class DerivationScheme
+        {
+            public string Crypto { get; set; }
+            public string Value { get; set; }
+        }
         class Format
         {
             public string Name { get; set; }
@@ -18,14 +23,9 @@ namespace BTCPayServer.Models.StoreViewModels
         }
         public StoreViewModel()
         {
-            var btcPay = new Format { Name = "BTCPay", Value = "BTCPay" };
-            DerivationSchemeFormat = btcPay.Value;
-            DerivationSchemeFormats = new SelectList(new Format[]
-            {
-                btcPay,
-                new Format { Name = "Electrum", Value = "Electrum" },
-            }, nameof(btcPay.Value), nameof(btcPay.Name), btcPay);
+
         }
+
         public string Id { get; set; }
         [Display(Name = "Store Name")]
         [Required]
@@ -45,21 +45,36 @@ namespace BTCPayServer.Models.StoreViewModels
             set;
         }
 
-        public string DerivationScheme
+        public List<StoreViewModel.DerivationScheme> DerivationSchemes { get; set; } = new List<StoreViewModel.DerivationScheme>();
+
+        [Display(Name = "Preferred price source (eg. bitfinex, bitstamp...)")]
+        public string PreferredExchange { get; set; }
+
+        public string RateSource
         {
-            get; set;
+            get
+            {
+                return PreferredExchange.IsCoinAverage() ? "https://apiv2.bitcoinaverage.com/indices/global/ticker/short" : $"https://apiv2.bitcoinaverage.com/exchanges/{PreferredExchange}";
+            }
         }
 
-        [Display(Name = "Derivation Scheme format")]
-        public string DerivationSchemeFormat
+        [Display(Name = "Multiply the original rate by ...")]
+        [Range(0.01, 10.0)]
+        public double RateMultiplier
         {
             get;
             set;
         }
 
-        public SelectList DerivationSchemeFormats { get; set; }
+        [Display(Name = "Invoice expires if the full amount has not been paid after ... minutes")]
+        [Range(1, 60 * 24 * 31)]
+        public int InvoiceExpiration
+        {
+            get;
+            set;
+        }
 
-        [Display(Name = "Payment invalid if transactions fails to confirm after ... minutes")]
+        [Display(Name = "Payment invalid if transactions fails to confirm ... minutes after invoice expiration")]
         [Range(10, 60 * 24 * 31)]
         public int MonitoringExpiration
         {
@@ -79,14 +94,21 @@ namespace BTCPayServer.Models.StoreViewModels
             get; set;
         }
 
-        public List<(string KeyPath, string Address)> AddressSamples
-        {
-            get; set;
-        } = new List<(string KeyPath, string Address)>();
-
         public string StatusMessage
         {
             get; set;
         }
+        public SelectList CryptoCurrencies { get; set; }
+
+        [Display(Name = "Default crypto currency on checkout")]
+        public string DefaultCryptoCurrency { get; set; }
+
+        public void SetCryptoCurrencies(ExplorerClientProvider explorerProvider, string defaultCrypto)
+        {
+            var choices = explorerProvider.GetAll().Select(o => new Format() { Name = o.Item1.CryptoCode, Value = o.Item1.CryptoCode }).ToArray();
+            var chosen = choices.FirstOrDefault(f => f.Name == defaultCrypto) ?? choices.FirstOrDefault();
+            CryptoCurrencies = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
+            DefaultCryptoCurrency = chosen.Name;
+        }
     }
 }

BTCPayServer/Models/StoreViewModels/StoresViewModel.cs

@@ -32,7 +32,7 @@ namespace BTCPayServer.Models.StoreViewModels
             {
                 get; set;
             }
-            public Money Balance
+            public string[] Balances
             {
                 get; set;
             }

BTCPayServer/NBXplorerWaiter.cs

@@ -1,175 +0,0 @@
-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/Program.cs

@@ -24,7 +24,8 @@ namespace BTCPayServer
         {
             ServicePointManager.DefaultConnectionLimit = 100;
             IWebHost host = null;
-            CustomConsoleLogProvider loggerProvider = new CustomConsoleLogProvider();
+            var processor = new ConsoleLoggerProcessor();
+            CustomConsoleLogProvider loggerProvider = new CustomConsoleLogProvider(processor);
 
             var loggerFactory = new LoggerFactory();
             loggerFactory.AddProvider(loggerProvider);
@@ -44,7 +45,8 @@ namespace BTCPayServer
                     .ConfigureLogging(l =>
                     {
                         l.AddFilter("Microsoft", LogLevel.Error);
-                        l.AddProvider(new CustomConsoleLogProvider());
+                        l.AddFilter("Microsoft.AspNetCore.Antiforgery.Internal", LogLevel.Critical);
+                        l.AddProvider(new CustomConsoleLogProvider(processor));
                     })
                     .UseStartup<Startup>()
                     .Build();
@@ -61,13 +63,9 @@ namespace BTCPayServer
                 if (!string.IsNullOrEmpty(ex.Message))
                     Logs.Configuration.LogError(ex.Message);
             }
-            catch (Exception exception)
-            {
-                logger.LogError("Exception thrown while running the server");
-                logger.LogError(exception.ToString());
-            }
             finally
             {
+                processor.Dispose();
                 if (host != null)
                     host.Dispose();
                 loggerProvider.Dispose();

BTCPayServer/Properties/launchSettings.json

@@ -1,26 +1,29 @@
 {
-    "iisSettings": {
-        "windowsAuthentication": false,
-        "anonymousAuthentication": true,
-        "iisExpress": {
-            "applicationUrl": "http://localhost:14139/",
-            "sslPort": 0
-        }
-    },
-    "profiles": {
-        "Default": {
-            "commandName": "Project"
-        },
-        "Docker-Regtest": {
-            "commandName": "Project",
-            "launchBrowser": true,
-            "environmentVariables": {
-                "BTCPAY_EXPLORERURL": "http://127.0.0.1:32838/",
-                "BTCPAY_NETWORK": "regtest",
-                "ASPNETCORE_ENVIRONMENT": "Development",
-                "BTCPAY_POSTGRES": "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver"
-            },
-            "applicationUrl": "http://localhost:14142/"
-        }
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:14139/",
+      "sslPort": 0
     }
+  },
+  "profiles": {
+    "Default": {
+      "commandName": "Project",
+      "commandLineArgs": "--network testnet --chains ltc --ltcexplorerurl http://127.0.0.1:2727/"
+    },
+    "Docker-Regtest": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "BTCPAY_NETWORK": "regtest",
+        "BTCPAY_LTCEXPLORERURL": "http://127.0.0.1:32838/",
+        "BTCPAY_BTCEXPLORERURL": "http://127.0.0.1:32838/",
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "BTCPAY_CHAINS": "btc,ltc",
+        "BTCPAY_POSTGRES": "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver"
+      },
+      "applicationUrl": "http://localhost:14142/"
+    }
+  }
 }

BTCPayServer/Services/BTCPayServerEnvironment.cs

@@ -5,12 +5,13 @@ using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using System.Text;
+using NBXplorer;
 
 namespace BTCPayServer.Services
 {
     public class BTCPayServerEnvironment
     {
-        public BTCPayServerEnvironment(IHostingEnvironment env)
+        public BTCPayServerEnvironment(IHostingEnvironment env, BTCPayNetworkProvider provider)
         {
             Version = typeof(BTCPayServerEnvironment).GetTypeInfo().Assembly.GetCustomAttribute<AssemblyFileVersionAttribute>().Version;
 #if DEBUG
@@ -19,11 +20,13 @@ namespace BTCPayServer.Services
 			Build = "Release";
 #endif
             Environment = env;
+            ChainType = provider.NBXplorerNetworkProvider.ChainType;
         }
         public IHostingEnvironment Environment
         {
             get; set;
         }
+        public ChainType ChainType { get; set; }
         public string Version
         {
             get; set;

BTCPayServer/Services/Fees/NBxplorerFeeProvider.cs

@@ -10,43 +10,38 @@ namespace BTCPayServer.Services.Fees
 {
     public class NBXplorerFeeProviderFactory : IFeeProviderFactory
     {
-        public NBXplorerFeeProviderFactory(ExplorerClient explorerClient)
+        public NBXplorerFeeProviderFactory(ExplorerClientProvider explorerClients)
         {
-            if (explorerClient == null)
-                throw new ArgumentNullException(nameof(explorerClient));
-            _ExplorerClient = explorerClient;
+            if (explorerClients == null)
+                throw new ArgumentNullException(nameof(explorerClients));
+            _ExplorerClients = explorerClients;
         }
 
-        private readonly ExplorerClient _ExplorerClient;
-        public ExplorerClient ExplorerClient
-        {
-            get
-            {
-                return _ExplorerClient;
-            }
-        }
+        private readonly ExplorerClientProvider _ExplorerClients;
 
         public FeeRate Fallback { get; set; }
         public int BlockTarget { get; set; }
         public IFeeProvider CreateFeeProvider(BTCPayNetwork network)
         {
-            return new NBXplorerFeeProvider(this);
+            return new NBXplorerFeeProvider(this, _ExplorerClients.GetExplorerClient(network));
         }
     }
     public class NBXplorerFeeProvider : IFeeProvider
     {
-        public NBXplorerFeeProvider(NBXplorerFeeProviderFactory factory)
+        public NBXplorerFeeProvider(NBXplorerFeeProviderFactory parent, ExplorerClient explorerClient)
         {
-            if (factory == null)
-                throw new ArgumentNullException(nameof(factory));
-            _Factory = factory;
+            if (explorerClient == null)
+                throw new ArgumentNullException(nameof(explorerClient));
+            _Factory = parent;
+            _ExplorerClient = explorerClient;
         }
-        private readonly NBXplorerFeeProviderFactory _Factory;
+        NBXplorerFeeProviderFactory _Factory;
+        ExplorerClient _ExplorerClient;
         public async Task<FeeRate> GetFeeRateAsync()
         {
             try
             {
-                return (await _Factory.ExplorerClient.GetFeeRateAsync(_Factory.BlockTarget).ConfigureAwait(false)).FeeRate;
+                return (await _ExplorerClient.GetFeeRateAsync(_Factory.BlockTarget).ConfigureAwait(false)).FeeRate;
             }
             catch (NBXplorerException ex) when (ex.Error.HttpCode == 400 && ex.Error.Code == "fee-estimation-unavailable")
             {

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using BTCPayServer.Models;
-using NBitpayClient;
 using Newtonsoft.Json.Linq;
 using NBitcoin.DataEncoders;
 using BTCPayServer.Data;
@@ -153,11 +152,64 @@ namespace BTCPayServer.Services.Invoices
             get;
             set;
         }
+
+        [Obsolete("Use GetDerivationStrategies instead")]
         public string DerivationStrategy
         {
             get;
             set;
         }
+
+        [Obsolete("Use GetDerivationStrategies instead")]
+        public string DerivationStrategies
+        {
+            get;
+            set;
+        }
+
+        public IEnumerable<DerivationStrategy> GetDerivationStrategies(BTCPayNetworkProvider networks)
+        {
+#pragma warning disable CS0618
+            bool btcReturned = false;
+            if (!string.IsNullOrEmpty(DerivationStrategies))
+            {
+                JObject strategies = JObject.Parse(DerivationStrategies);
+                foreach (var strat in strategies.Properties())
+                {
+                    var network = networks.GetNetwork(strat.Name);
+                    if (network != null)
+                    {
+                        if (network == networks.BTC)
+                            btcReturned = true;
+                        yield return BTCPayServer.DerivationStrategy.Parse(strat.Value.Value<string>(), network);
+                    }
+                }
+            }
+
+            if (!btcReturned && !string.IsNullOrEmpty(DerivationStrategy))
+            {
+                if (networks.BTC != null)
+                {
+                    yield return BTCPayServer.DerivationStrategy.Parse(DerivationStrategy, networks.BTC);
+                }
+            }
+#pragma warning restore CS0618
+        }
+
+        internal void SetDerivationStrategies(IEnumerable<DerivationStrategy> derivationStrategies)
+        {
+            JObject obj = new JObject();
+            foreach (var strat in derivationStrategies)
+            {
+                obj.Add(strat.Network.CryptoCode, new JValue(strat.DerivationStrategyBase.ToString()));
+#pragma warning disable CS0618
+                if (strat.Network.IsBTC)
+                    DerivationStrategy = strat.DerivationStrategyBase.ToString();
+            }
+            DerivationStrategies = JsonConvert.SerializeObject(obj);
+#pragma warning restore CS0618
+        }
+
         public string Status
         {
             get;
@@ -167,10 +219,27 @@ namespace BTCPayServer.Services.Invoices
         {
             get; set;
         }
+
+        [Obsolete("Use GetPayments instead")]
         public List<PaymentEntity> Payments
         {
             get; set;
         }
+
+#pragma warning disable CS0618
+        public List<PaymentEntity> GetPayments()
+        {
+            return Payments.ToList();
+        }
+        public List<PaymentEntity> GetPayments(string cryptoCode)
+        {
+            return Payments.Where(p => p.CryptoCode == cryptoCode).ToList();
+        }
+        public List<PaymentEntity> GetPayments(BTCPayNetwork network)
+        {
+            return GetPayments(network.CryptoCode);
+        }
+#pragma warning restore CS0618
         public bool Refundable
         {
             get;
@@ -229,6 +298,8 @@ namespace BTCPayServer.Services.Invoices
             get;
             set;
         }
+        public bool ExtendedNotifications { get; set; }
+        public List<InvoiceEventData> Events { get; internal set; }
 
         public bool IsExpired()
         {
@@ -252,11 +323,11 @@ namespace BTCPayServer.Services.Invoices
                 Flags = new Flags() { Refundable = Refundable }
             };
 
-            dto.CryptoInfo = new List<InvoiceCryptoInfo>();
-            foreach (var info in this.GetCryptoData().Values)
+            dto.CryptoInfo = new List<NBitpayClient.InvoiceCryptoInfo>();
+            foreach (var info in this.GetCryptoData(networkProvider, true).Values)
             {
                 var accounting = info.Calculate();
-                var cryptoInfo = new InvoiceCryptoInfo();
+                var cryptoInfo = new NBitpayClient.InvoiceCryptoInfo();
                 cryptoInfo.CryptoCode = info.CryptoCode;
                 cryptoInfo.Rate = info.Rate;
                 cryptoInfo.Price = Money.Coins(ProductInformation.Price / cryptoInfo.Rate).ToString();
@@ -266,7 +337,7 @@ namespace BTCPayServer.Services.Invoices
                 cryptoInfo.TotalDue = accounting.TotalDue.ToString();
                 cryptoInfo.NetworkFee = accounting.NetworkFee.ToString();
                 cryptoInfo.TxCount = accounting.TxCount;
-                cryptoInfo.CryptoPaid = accounting.CryptoPaid;
+                cryptoInfo.CryptoPaid = accounting.CryptoPaid.ToString();
 
                 cryptoInfo.Address = info.DepositAddress;
                 cryptoInfo.ExRates = new Dictionary<string, double>
@@ -274,12 +345,12 @@ namespace BTCPayServer.Services.Invoices
                     { ProductInformation.Currency, (double)cryptoInfo.Rate }
                 };
 
-                var scheme = networkProvider.GetNetwork(info.CryptoCode)?.UriScheme ?? "BTC";
+                var scheme = info.Network.UriScheme;
                 var cryptoSuffix = cryptoInfo.CryptoCode == "BTC" ? "" : "/" + cryptoInfo.CryptoCode;
                 cryptoInfo.Url = ServerUrl.WithTrailingSlash() + $"invoice{cryptoSuffix}?id=" + Id;
 
 
-                cryptoInfo.PaymentUrls = new InvoicePaymentUrls()
+                cryptoInfo.PaymentUrls = new NBitpayClient.InvoicePaymentUrls()
                 {
                     BIP72 = $"{scheme}:{cryptoInfo.Address}?amount={cryptoInfo.Due}&r={ServerUrl.WithTrailingSlash() + ($"i/{Id}{cryptoSuffix}")}",
                     BIP72b = $"{scheme}:?r={ServerUrl.WithTrailingSlash() + ($"i/{Id}{cryptoSuffix}")}",
@@ -299,8 +370,8 @@ namespace BTCPayServer.Services.Invoices
                     dto.PaymentUrls = cryptoInfo.PaymentUrls;
                 }
 #pragma warning restore CS0618
-
-                dto.CryptoInfo.Add(cryptoInfo);
+                if(!info.IsPhantomBTC)
+                    dto.CryptoInfo.Add(cryptoInfo);
             }
 
             Populate(ProductInformation, dto);
@@ -321,40 +392,46 @@ namespace BTCPayServer.Services.Invoices
 
         internal bool Support(BTCPayNetwork network)
         {
-            var rates = GetCryptoData();
+            var rates = GetCryptoData(null);
             return rates.TryGetValue(network.CryptoCode, out var data);
         }
 
-        public CryptoData GetCryptoData(string cryptoCode)
+        public CryptoData GetCryptoData(string cryptoCode, BTCPayNetworkProvider networkProvider, bool alwaysIncludeBTC = false)
         {
-            GetCryptoData().TryGetValue(cryptoCode, out var data);
+            GetCryptoData(networkProvider, alwaysIncludeBTC).TryGetValue(cryptoCode, out var data);
             return data;
         }
 
-        public CryptoData GetCryptoData(BTCPayNetwork network)
+        public CryptoData GetCryptoData(BTCPayNetwork network, BTCPayNetworkProvider networkProvider)
         {
-            GetCryptoData().TryGetValue(network.CryptoCode, out var data);
+            GetCryptoData(networkProvider).TryGetValue(network.CryptoCode, out var data);
             return data;
         }
 
-        public Dictionary<string, CryptoData> GetCryptoData()
+        public Dictionary<string, CryptoData> GetCryptoData(BTCPayNetworkProvider networkProvider, bool alwaysIncludeBTC = false)
         {
             Dictionary<string, CryptoData> rates = new Dictionary<string, CryptoData>();
             var serializer = new Serializer(Dummy);
+            CryptoData phantom = null;
 #pragma warning disable CS0618
             // Legacy
-            if (Rate != 0.0m)
+            if (alwaysIncludeBTC)
             {
-                rates.TryAdd("BTC", new CryptoData() { ParentEntity = this, Rate = Rate, CryptoCode = "BTC", TxFee = TxFee, FeeRate = new FeeRate(TxFee, 100), DepositAddress = DepositAddress });
+                var btcNetwork = networkProvider?.GetNetwork("BTC");
+                phantom = new CryptoData() { ParentEntity = this, IsPhantomBTC = true, Rate = Rate, CryptoCode = "BTC", TxFee = TxFee, FeeRate = new FeeRate(TxFee, 100), DepositAddress = DepositAddress, Network = btcNetwork };
+                rates.Add("BTC", phantom);
             }
             if (CryptoData != null)
             {
                 foreach (var prop in CryptoData.Properties())
                 {
+                    if (prop.Name == "BTC" && phantom != null)
+                        rates.Remove("BTC");
                     var r = serializer.ToObject<CryptoData>(prop.Value.ToString());
                     r.CryptoCode = prop.Name;
                     r.ParentEntity = this;
-                    rates.TryAdd(r.CryptoCode, r);
+                    r.Network = networkProvider?.GetNetwork(r.CryptoCode);
+                    rates.Add(r.CryptoCode, r);
                 }
             }
 #pragma warning restore CS0618
@@ -362,6 +439,14 @@ namespace BTCPayServer.Services.Invoices
         }
 
         Network Dummy = Network.Main;
+
+        public void SetCryptoData(CryptoData cryptoData)
+        {
+            var dict = GetCryptoData(null);
+            dict.AddOrReplace(cryptoData.CryptoCode, cryptoData);
+            SetCryptoData(dict);
+        }
+
         public void SetCryptoData(Dictionary<string, CryptoData> cryptoData)
         {
             var obj = new JObject();
@@ -414,6 +499,8 @@ namespace BTCPayServer.Services.Invoices
     {
         [JsonIgnore]
         public InvoiceEntity ParentEntity { get; set; }
+        [JsonIgnore]
+        public BTCPayNetwork Network { get; set; }
         [JsonProperty(PropertyName = "cryptoCode", DefaultValueHandling = DefaultValueHandling.Ignore)]
         public string CryptoCode { get; set; }
         [JsonProperty(PropertyName = "rate")]
@@ -424,47 +511,59 @@ namespace BTCPayServer.Services.Invoices
         public Money TxFee { get; set; }
         [JsonProperty(PropertyName = "depositAddress")]
         public string DepositAddress { get; set; }
-        
+
+        [JsonIgnore]
+        public bool IsPhantomBTC { get; set; }
+
         public CryptoDataAccounting Calculate()
         {
-            var cryptoData = ParentEntity.GetCryptoData();
-            var totalDue = Money.Coins(ParentEntity.ProductInformation.Price / Rate) + TxFee;
+            var cryptoData = ParentEntity.GetCryptoData(null, IsPhantomBTC);
+            var totalDue = Money.Coins(ParentEntity.ProductInformation.Price / Rate);
             var paid = Money.Zero;
             var cryptoPaid = Money.Zero;
-            int txCount = 1;
+
+            var paidTxFee = Money.Zero;
+            bool paidEnough = totalDue <= paid;
+            int txCount = 0;
             var payments =
-                ParentEntity.Payments
+                ParentEntity.GetPayments()
                 .Where(p => p.Accounted)
-                .OrderByDescending(p => p.ReceivedTime)
+                .OrderBy(p => p.ReceivedTime)
                 .Select(_ =>
                 {
+                    var txFee = _.GetValue(cryptoData, CryptoCode, cryptoData[_.GetCryptoCode()].TxFee);
                     paid += _.GetValue(cryptoData, CryptoCode);
-                    if (CryptoCode == _.GetCryptoCode())
-                        cryptoPaid += _.GetValue();
-                    return _;
-                })
-                .TakeWhile(_ =>
-                {
-                    var paidEnough = totalDue <= paid;
-                    if (!paidEnough && _.GetCryptoCode() == CryptoCode)
+                    if (!paidEnough)
                     {
-                        txCount++;
-                        totalDue += TxFee;
+                        totalDue += txFee;
+                        paidTxFee += txFee;
                     }
-                    return !paidEnough;
+                    paidEnough |= totalDue <= paid;
+                    if (CryptoCode == _.GetCryptoCode())
+                    {
+                        cryptoPaid += _.GetValue();
+                        txCount++;
+                    }
+                    return _;
                 })
                 .ToArray();
 
+            if (!paidEnough)
+            {
+                txCount++;
+                totalDue += TxFee;
+                paidTxFee += TxFee;
+            }
             var accounting = new CryptoDataAccounting();
             accounting.TotalDue = totalDue;
             accounting.Paid = paid;
             accounting.TxCount = txCount;
             accounting.CryptoPaid = cryptoPaid;
             accounting.Due = Money.Max(accounting.TotalDue - accounting.Paid, Money.Zero);
-            accounting.NetworkFee = TxFee * txCount;
+            accounting.NetworkFee = paidTxFee;
             return accounting;
         }
-        
+
     }
 
     public class AccountedPaymentEntity
@@ -519,20 +618,21 @@ namespace BTCPayServer.Services.Invoices
             return Output.Value;
 #pragma warning restore CS0618
         }
-        public Money GetValue(Dictionary<string, CryptoData> cryptoData, string cryptoCode)
+        public Money GetValue(Dictionary<string, CryptoData> cryptoData, string cryptoCode, Money value = null)
         {
 #pragma warning disable CS0618
+            value = value ?? Output.Value;
+#pragma warning restore CS0618
             var to = cryptoCode;
             var from = GetCryptoCode();
             if (to == from)
-                return Output.Value;
+                return value;
             var fromRate = cryptoData[from].Rate;
             var toRate = cryptoData[to].Rate;
 
-            var fiatValue = fromRate * Output.Value.ToDecimal(MoneyUnit.BTC);
+            var fiatValue = fromRate * value.ToDecimal(MoneyUnit.BTC);
             var otherCurrencyValue = toRate == 0 ? 0.0m : fiatValue / toRate;
             return Money.Coins(otherCurrencyValue);
-#pragma warning restore CS0618
         }
 
         public string GetCryptoCode()

BTCPayServer/Services/Invoices/InvoiceRepository.cs

@@ -1,4 +1,5 @@
 using DBreeze;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -16,6 +17,7 @@ using System.Threading.Tasks;
 using BTCPayServer.Data;
 using System.Globalization;
 using BTCPayServer.Models.InvoicingModels;
+using BTCPayServer.Logging;
 
 namespace BTCPayServer.Services.Invoices
 {
@@ -32,32 +34,18 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-
-        Network _Network;
-        public Network Network
-        {
-            get
-            {
-                return _Network;
-            }
-            set
-            {
-                _Network = value;
-            }
-        }
-
         private ApplicationDbContextFactory _ContextFactory;
         private CustomThreadPool _IndexerThread;
-        public InvoiceRepository(ApplicationDbContextFactory contextFactory, string dbreezePath, Network network)
+        public InvoiceRepository(ApplicationDbContextFactory contextFactory, string dbreezePath)
         {
             _Engine = new DBreezeEngine(dbreezePath);
             _IndexerThread = new CustomThreadPool(1, "Invoice Indexer");
-            _Network = network;
             _ContextFactory = contextFactory;
         }
 
         public async Task<bool> RemovePendingInvoice(string invoiceId)
         {
+            Logs.PayServer.LogInformation($"Remove pending invoice {invoiceId}");
             using (var ctx = _ContextFactory.CreateContext())
             {
                 ctx.PendingInvoices.Remove(new PendingInvoiceData() { Id = invoiceId });
@@ -70,11 +58,11 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        public async Task<string> GetInvoiceIdFromScriptPubKey(Script scriptPubKey)
+        public async Task<string> GetInvoiceIdFromScriptPubKey(Script scriptPubKey, string cryptoCode)
         {
             using (var db = _ContextFactory.CreateContext())
             {
-                var result = await db.AddressInvoices.FindAsync(scriptPubKey.Hash.ToString());
+                var result = await db.AddressInvoices.FindAsync(scriptPubKey.Hash.ToString() + "#" + cryptoCode);
                 return result?.InvoiceDataId;
             }
         }
@@ -105,9 +93,11 @@ namespace BTCPayServer.Services.Invoices
         public async Task<InvoiceEntity> CreateInvoiceAsync(string storeId, InvoiceEntity invoice, BTCPayNetworkProvider networkProvider)
         {
             List<string> textSearch = new List<string>();
-            invoice = Clone(invoice);
+            invoice = Clone(invoice, null);
             invoice.Id = Encoders.Base58.EncodeData(RandomUtils.GetBytes(16));
+#pragma warning disable CS0618
             invoice.Payments = new List<PaymentEntity>();
+#pragma warning restore CS0618
             invoice.StoreId = storeId;
             using (var context = _ContextFactory.CreateContext())
             {
@@ -116,33 +106,27 @@ namespace BTCPayServer.Services.Invoices
                     StoreDataId = storeId,
                     Id = invoice.Id,
                     Created = invoice.InvoiceTime,
-                    Blob = ToBytes(invoice),
+                    Blob = ToBytes(invoice, null),
                     OrderId = invoice.OrderId,
                     Status = invoice.Status,
                     ItemCode = invoice.ProductInformation.ItemCode,
                     CustomerEmail = invoice.RefundMail
                 });
 
-                foreach (var cryptoData in invoice.GetCryptoData().Values)
+                foreach (var cryptoData in invoice.GetCryptoData(networkProvider).Values)
                 {
-                    var network = networkProvider.GetNetwork(cryptoData.CryptoCode);
-                    if (network == null)
+                    if (cryptoData.Network == null)
                         throw new InvalidOperationException("CryptoCode unsupported");
                     context.AddressInvoices.Add(new AddressInvoiceData()
                     {
-                        Address = BitcoinAddress.Create(cryptoData.DepositAddress, network.NBitcoinNetwork).ScriptPubKey.Hash.ToString(),
                         InvoiceDataId = invoice.Id,
                         CreatedTime = DateTimeOffset.UtcNow,
-                    });
+                    }.SetHash(BitcoinAddress.Create(cryptoData.DepositAddress, cryptoData.Network.NBitcoinNetwork).ScriptPubKey.Hash, cryptoData.CryptoCode));
                     context.HistoricalAddressInvoices.Add(new HistoricalAddressInvoiceData()
                     {
                         InvoiceDataId = invoice.Id,
-                        Address = cryptoData.DepositAddress,
-#pragma warning disable CS0618
-                        CryptoCode = cryptoData.CryptoCode,
-#pragma warning restore CS0618
                         Assigned = DateTimeOffset.UtcNow
-                    });
+                    }.SetAddress(cryptoData.DepositAddress, cryptoData.CryptoCode));
                     textSearch.Add(cryptoData.DepositAddress);
                     textSearch.Add(cryptoData.Calculate().TotalDue.ToString());
                 }
@@ -154,8 +138,8 @@ namespace BTCPayServer.Services.Invoices
             textSearch.Add(invoice.InvoiceTime.ToString(CultureInfo.InvariantCulture));
             textSearch.Add(invoice.ProductInformation.Price.ToString(CultureInfo.InvariantCulture));
             textSearch.Add(invoice.OrderId);
-            textSearch.Add(ToString(invoice.BuyerInformation));
-            textSearch.Add(ToString(invoice.ProductInformation));
+            textSearch.Add(ToString(invoice.BuyerInformation, null));
+            textSearch.Add(ToString(invoice.ProductInformation, null));
             textSearch.Add(invoice.StoreId);
 
             AddToTextSearch(invoice.Id, textSearch.ToArray());
@@ -171,9 +155,8 @@ namespace BTCPayServer.Services.Invoices
                 if (invoice == null)
                     return false;
 
-                var invoiceEntity = ToObject<InvoiceEntity>(invoice.Blob);
-                var cryptoData = invoiceEntity.GetCryptoData();
-                var currencyData = cryptoData.Where(c => c.Value.CryptoCode == network.CryptoCode).Select(f => f.Value).FirstOrDefault();
+                var invoiceEntity = ToObject<InvoiceEntity>(invoice.Blob, network.NBitcoinNetwork);
+                var currencyData = invoiceEntity.GetCryptoData(network, null);
                 if (currencyData == null)
                     return false;
 
@@ -185,21 +168,25 @@ namespace BTCPayServer.Services.Invoices
                 currencyData.DepositAddress = bitcoinAddress.ToString();
 
 #pragma warning disable CS0618
-                if (network.CryptoCode == "BTC")
+                if (network.IsBTC)
                 {
                     invoiceEntity.DepositAddress = currencyData.DepositAddress;
                 }
-#pragma warning disable CS0618
-                invoiceEntity.SetCryptoData(cryptoData);
-                invoice.Blob = ToBytes(invoiceEntity);
+#pragma warning restore CS0618
+                invoiceEntity.SetCryptoData(currencyData);
+                invoice.Blob = ToBytes(invoiceEntity, network.NBitcoinNetwork);
 
-                context.AddressInvoices.Add(new AddressInvoiceData() { Address = bitcoinAddress.ScriptPubKey.Hash.ToString(), InvoiceDataId = invoiceId, CreatedTime = DateTimeOffset.UtcNow });
+                context.AddressInvoices.Add(new AddressInvoiceData()
+                {
+                    InvoiceDataId = invoiceId,
+                    CreatedTime = DateTimeOffset.UtcNow
+                }
+                .SetHash(bitcoinAddress.ScriptPubKey.Hash, network.CryptoCode));
                 context.HistoricalAddressInvoices.Add(new HistoricalAddressInvoiceData()
                 {
                     InvoiceDataId = invoiceId,
-                    Address = bitcoinAddress.ToString(),
                     Assigned = DateTimeOffset.UtcNow
-                });
+                }.SetAddress(bitcoinAddress.ToString(), network.CryptoCode));
 
                 await context.SaveChangesAsync();
                 AddToTextSearch(invoice.Id, bitcoinAddress.ToString());
@@ -207,15 +194,30 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
+        public async Task AddInvoiceEvent(string invoiceId, object evt)
+        {
+            using (var context = _ContextFactory.CreateContext())
+            {
+                context.InvoiceEvents.Add(new InvoiceEventData()
+                {
+                    InvoiceDataId = invoiceId,
+                    Message = evt.ToString(),
+                    Timestamp = DateTimeOffset.UtcNow,
+                    UniqueId = Encoders.Hex.EncodeData(RandomUtils.GetBytes(10))
+                });
+                await context.SaveChangesAsync();
+            }
+        }
+
         private static void MarkUnassigned(string invoiceId, InvoiceEntity entity, ApplicationDbContext context, string cryptoCode)
         {
-            foreach (var address in entity.GetCryptoData())
+            foreach (var address in entity.GetCryptoData(null))
             {
                 if (cryptoCode != null && cryptoCode != address.Value.CryptoCode)
                     continue;
                 var historical = new HistoricalAddressInvoiceData();
                 historical.InvoiceDataId = invoiceId;
-                historical.Address = address.Value.DepositAddress;
+                historical.SetAddress(address.Value.DepositAddress, address.Value.CryptoCode);
                 historical.UnAssigned = DateTimeOffset.UtcNow;
                 context.Attach(historical);
                 context.Entry(historical).Property(o => o.UnAssigned).IsModified = true;
@@ -229,7 +231,7 @@ namespace BTCPayServer.Services.Invoices
                 var invoiceData = await context.FindAsync<InvoiceData>(invoiceId).ConfigureAwait(false);
                 if (invoiceData == null)
                     return;
-                var invoiceEntity = ToObject<InvoiceEntity>(invoiceData.Blob);
+                var invoiceEntity = ToObject<InvoiceEntity>(invoiceData.Blob, null);
                 MarkUnassigned(invoiceId, invoiceEntity, context, null);
                 try
                 {
@@ -312,13 +314,15 @@ namespace BTCPayServer.Services.Invoices
 
         private InvoiceEntity ToEntity(InvoiceData invoice)
         {
-            var entity = ToObject<InvoiceEntity>(invoice.Blob);
+            var entity = ToObject<InvoiceEntity>(invoice.Blob, null);
+#pragma warning disable CS0618
             entity.Payments = invoice.Payments.Select(p =>
             {
-                var paymentEntity = ToObject<PaymentEntity>(p.Blob);
+                var paymentEntity = ToObject<PaymentEntity>(p.Blob, null);
                 paymentEntity.Accounted = p.Accounted;
                 return paymentEntity;
             }).ToList();
+#pragma warning restore CS0618
             entity.ExceptionStatus = invoice.ExceptionStatus;
             entity.Status = invoice.Status;
             entity.RefundMail = invoice.CustomerEmail;
@@ -329,13 +333,16 @@ namespace BTCPayServer.Services.Invoices
             }
             if (invoice.AddressInvoices != null)
             {
-                entity.AvailableAddressHashes = invoice.AddressInvoices.Select(a => a.Address).ToHashSet();
+                entity.AvailableAddressHashes = invoice.AddressInvoices.Select(a => a.GetHash() + a.GetCryptoCode()).ToHashSet();
+            }
+            if(invoice.Events != null)
+            {
+                entity.Events = invoice.Events.OrderBy(c => c.Timestamp).ToList();
             }
             return entity;
         }
 
 
-
         public async Task<InvoiceEntity[]> GetInvoices(InvoiceQuery queryObject)
         {
             using (var context = _ContextFactory.CreateContext())
@@ -344,7 +351,10 @@ namespace BTCPayServer.Services.Invoices
                     .Invoices
                     .Include(o => o.Payments)
                     .Include(o => o.RefundAddresses);
-
+                if (queryObject.IncludeAddresses)
+                    query = query.Include(o => o.HistoricalAddressInvoices).Include(o => o.AddressInvoices);
+                if (queryObject.IncludeEvents)
+                    query = query.Include(o => o.Events);
                 if (!string.IsNullOrEmpty(queryObject.InvoiceId))
                 {
                     query = query.Where(i => i.Id == queryObject.InvoiceId);
@@ -398,7 +408,7 @@ namespace BTCPayServer.Services.Invoices
 
         }
 
-        public async Task AddRefundsAsync(string invoiceId, TxOut[] outputs)
+        public async Task AddRefundsAsync(string invoiceId, TxOut[] outputs, Network network)
         {
             if (outputs.Length == 0)
                 return;
@@ -412,32 +422,35 @@ namespace BTCPayServer.Services.Invoices
                     {
                         Id = invoiceId + "-" + i,
                         InvoiceDataId = invoiceId,
-                        Blob = ToBytes(output)
+                        Blob = ToBytes(output, network)
                     });
                     i++;
                 }
                 await context.SaveChangesAsync().ConfigureAwait(false);
             }
 
-            var addresses = outputs.Select(o => o.ScriptPubKey.GetDestinationAddress(_Network)).Where(a => a != null).ToArray();
+            var addresses = outputs.Select(o => o.ScriptPubKey.GetDestinationAddress(network)).Where(a => a != null).ToArray();
             AddToTextSearch(invoiceId, addresses.Select(a => a.ToString()).ToArray());
         }
 
-        public async Task<PaymentEntity> AddPayment(string invoiceId, Coin receivedCoin)
+        public async Task<PaymentEntity> AddPayment(string invoiceId, DateTimeOffset date, Coin receivedCoin, string cryptoCode)
         {
             using (var context = _ContextFactory.CreateContext())
             {
                 PaymentEntity entity = new PaymentEntity
                 {
                     Outpoint = receivedCoin.Outpoint,
+#pragma warning disable CS0618
                     Output = receivedCoin.TxOut,
-                    ReceivedTime = DateTime.UtcNow
+                    CryptoCode = cryptoCode,
+#pragma warning restore CS0618
+                    ReceivedTime = date.UtcDateTime
                 };
 
                 PaymentData data = new PaymentData
                 {
                     Id = receivedCoin.Outpoint.ToString(),
-                    Blob = ToBytes(entity),
+                    Blob = ToBytes(entity, null),
                     InvoiceDataId = invoiceId
                 };
 
@@ -449,7 +462,7 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        public async Task UpdatePayments(List<AccountedPaymentEntity> payments)
+        public async Task UpdatePayments(List<PaymentEntity> payments)
         {
             if (payments.Count == 0)
                 return;
@@ -458,8 +471,8 @@ namespace BTCPayServer.Services.Invoices
                 foreach (var payment in payments)
                 {
                     var data = new PaymentData();
-                    data.Id = payment.Payment.Outpoint.ToString();
-                    data.Accounted = payment.Payment.Accounted;
+                    data.Id = payment.Outpoint.ToString();
+                    data.Accounted = payment.Accounted;
                     context.Attach(data);
                     context.Entry(data).Property(o => o.Accounted).IsModified = true;
                 }
@@ -467,24 +480,24 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        private T ToObject<T>(byte[] value)
+        private T ToObject<T>(byte[] value, Network network)
         {
-            return NBitcoin.JsonConverters.Serializer.ToObject<T>(ZipUtils.Unzip(value), Network);
+            return NBitcoin.JsonConverters.Serializer.ToObject<T>(ZipUtils.Unzip(value), network);
         }
 
-        private byte[] ToBytes<T>(T obj)
+        private byte[] ToBytes<T>(T obj, Network network)
         {
-            return ZipUtils.Zip(NBitcoin.JsonConverters.Serializer.ToString(obj));
+            return ZipUtils.Zip(NBitcoin.JsonConverters.Serializer.ToString(obj, network));
         }
 
-        private T Clone<T>(T invoice)
+        private T Clone<T>(T invoice, Network network)
         {
-            return NBitcoin.JsonConverters.Serializer.ToObject<T>(ToString(invoice), Network);
+            return NBitcoin.JsonConverters.Serializer.ToObject<T>(ToString(invoice, network), network);
         }
 
-        private string ToString<T>(T data)
+        private string ToString<T>(T data, Network network)
         {
-            return NBitcoin.JsonConverters.Serializer.ToString(data, Network);
+            return NBitcoin.JsonConverters.Serializer.ToString(data, network);
         }
 
         public void Dispose()
@@ -549,5 +562,8 @@ namespace BTCPayServer.Services.Invoices
             get;
             set;
         }
+        public bool IncludeAddresses { get; set; }
+
+        public bool IncludeEvents { get; set; }
     }
 }

BTCPayServer/Services/Invoices/InvoiceWatcher.cs

@@ -1,421 +0,0 @@
-using NBXplorer;
-using Microsoft.Extensions.Logging;
-using NBXplorer.DerivationStrategy;
-using NBXplorer.Models;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using NBitcoin;
-using BTCPayServer.Logging;
-using System.Threading;
-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;
-        EventAggregator _EventAggregator;
-        BTCPayWallet _Wallet;
-        BTCPayNetworkProvider _NetworkProvider;
-
-        public InvoiceWatcher(ExplorerClient explorerClient,
-            BTCPayNetworkProvider networkProvider,
-            InvoiceRepository invoiceRepository,
-            EventAggregator eventAggregator,
-            BTCPayWallet wallet,
-            InvoiceWatcherAccessor accessor)
-        {
-            LongPollingMode = explorerClient.Network == Network.RegTest;
-            PollInterval = explorerClient.Network == Network.RegTest ? TimeSpan.FromSeconds(10.0) : TimeSpan.FromMinutes(1.0);
-            _Wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
-            _ExplorerClient = explorerClient ?? throw new ArgumentNullException(nameof(explorerClient));
-            _DerivationFactory = new DerivationStrategyFactory(_ExplorerClient.Network);
-            _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
-            _EventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
-            _NetworkProvider = networkProvider;
-            accessor.Instance = this;
-        }
-        CompositeDisposable leases = new CompositeDisposable();
-
-        public bool LongPollingMode
-        {
-            get; set;
-        }
-
-        async Task NotifyReceived(Script scriptPubKey)
-        {
-            var invoice = await _InvoiceRepository.GetInvoiceIdFromScriptPubKey(scriptPubKey);
-            if (invoice != null)
-                _WatchRequests.Add(invoice);
-        }
-
-        async Task NotifyBlock()
-        {
-            foreach (var invoice in await _InvoiceRepository.GetPendingInvoices())
-            {
-                _WatchRequests.Add(invoice);
-            }
-        }
-
-        private async Task UpdateInvoice(string invoiceId)
-        {
-            UTXOChanges changes = null;
-            while (true)
-            {
-                try
-                {
-                    var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, true).ConfigureAwait(false);
-                    if (invoice == null)
-                        break;
-                    var stateBefore = invoice.Status;
-                    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);
-                        _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))
-                    {
-                        if (await _InvoiceRepository.RemovePendingInvoice(invoice.Id).ConfigureAwait(false))
-                            Logs.PayServer.LogInformation("Stopped watching invoice " + invoiceId);
-                        break;
-                    }
-
-                    if (!changed || _Cts.Token.IsCancellationRequested)
-                        break;
-                }
-                catch (OperationCanceledException) when (_Cts.Token.IsCancellationRequested)
-                {
-                    break;
-                }
-                catch (Exception ex)
-                {
-                    Logs.PayServer.LogError(ex, "Unhandled error on watching invoice " + invoiceId);
-                    await Task.Delay(10000, _Cts.Token).ConfigureAwait(false);
-                }
-            }
-        }
-
-
-        private async Task<(bool NeedSave, UTXOChanges Changes)> UpdateInvoice(UTXOChanges changes, InvoiceEntity invoice, List<Action> postSaveActions)
-        {
-            bool needSave = false;
-            //Fetch unknown payments
-            var strategy = _DerivationFactory.Parse(invoice.DerivationStrategy);
-            changes = await _ExplorerClient.SyncAsync(strategy, changes, !LongPollingMode, _Cts.Token).ConfigureAwait(false);
-
-
-            var utxos = changes.Confirmed.UTXOs.Concat(changes.Unconfirmed.UTXOs).ToArray();
-            List<Coin> receivedCoins = new List<Coin>();
-            foreach (var received in utxos)
-                if (invoice.AvailableAddressHashes.Contains(received.ScriptPubKey.Hash.ToString()))
-                    receivedCoins.Add(received.AsCoin());
-
-            var alreadyAccounted = new HashSet<OutPoint>(invoice.Payments.Select(p => p.Outpoint));
-            bool dirtyAddress = false;
-            foreach (var coin in receivedCoins.Where(c => !alreadyAccounted.Contains(c.Outpoint)))
-            {
-                var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin).ConfigureAwait(false);
-                invoice.Payments.Add(payment);
-                postSaveActions.Add(() => _EventAggregator.Publish(new InvoicePaymentEvent(invoice.Id)));
-                dirtyAddress = true;
-            }
-            //////
-            var network = _NetworkProvider.GetNetwork("BTC");
-            var cryptoData = invoice.GetCryptoData(network);
-            var cryptoDataAll = invoice.GetCryptoData();
-            var accounting = cryptoData.Calculate();
-            if (invoice.Status == "new" && invoice.ExpirationTime < DateTimeOffset.UtcNow)
-            {
-                needSave = true;
-                await _InvoiceRepository.UnaffectAddress(invoice.Id);
-
-                postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "expired")));
-                invoice.Status = "expired";
-            }
-
-            if (invoice.Status == "new" || invoice.Status == "expired")
-            {
-                var totalPaid = (await GetPaymentsWithTransaction(invoice)).Select(p => p.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                if (totalPaid >= accounting.TotalDue)
-                {
-                    if (invoice.Status == "new")
-                    {
-                        postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "paid")));
-                        invoice.Status = "paid";
-                        invoice.ExceptionStatus = null;
-                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                        needSave = true;
-                    }
-                    else if (invoice.Status == "expired")
-                    {
-                        invoice.ExceptionStatus = "paidLate";
-                        needSave = true;
-                    }
-                }
-
-                if (totalPaid > accounting.TotalDue && invoice.ExceptionStatus != "paidOver")
-                {
-                    invoice.ExceptionStatus = "paidOver";
-                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    needSave = true;
-                }
-
-                if (totalPaid < accounting.TotalDue && invoice.Payments.Count != 0 && invoice.ExceptionStatus != "paidPartial")
-                {
-                    Logs.PayServer.LogInformation("Paid to " + cryptoData.DepositAddress);
-                    invoice.ExceptionStatus = "paidPartial";
-                    needSave = true;
-                    if (dirtyAddress)
-                    {
-                        var address = await _Wallet.ReserveAddressAsync(_DerivationFactory.Parse(invoice.DerivationStrategy));
-                        Logs.PayServer.LogInformation("Generate new " + address);
-                        await _InvoiceRepository.NewAddress(invoice.Id, address, network);
-                    }
-                }
-            }
-
-            if (invoice.Status == "paid")
-            {
-                var transactions = await GetPaymentsWithTransaction(invoice);
-                var chainConfirmedTransactions = transactions.Where(t => t.Confirmations >= 1);
-                if (invoice.SpeedPolicy == SpeedPolicy.HighSpeed)
-                {
-                    transactions = transactions.Where(t => !t.Transaction.RBF);
-                }
-                else if (invoice.SpeedPolicy == SpeedPolicy.MediumSpeed)
-                {
-                    transactions = transactions.Where(t => t.Confirmations >= 1);
-                }
-                else if (invoice.SpeedPolicy == SpeedPolicy.LowSpeed)
-                {
-                    transactions = transactions.Where(t => t.Confirmations >= 6);
-                }
-
-                var chainTotalConfirmed = chainConfirmedTransactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-
-                if (// Is after the monitoring deadline
-                   (invoice.MonitoringExpiration < DateTimeOffset.UtcNow)
-                   &&
-                   // And not enough amount confirmed
-                   (chainTotalConfirmed < accounting.TotalDue))
-                {
-                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "invalid")));
-                    invoice.Status = "invalid";
-                    needSave = true;
-                }
-                else
-                {
-                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                    if (totalConfirmed >= accounting.TotalDue)
-                    {
-                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                        postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "confirmed")));
-                        invoice.Status = "confirmed";
-                        needSave = true;
-                    }
-                }
-            }
-
-            if (invoice.Status == "confirmed")
-            {
-                var transactions = await GetPaymentsWithTransaction(invoice);
-                transactions = transactions.Where(t => t.Confirmations >= 6);
-                var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                if (totalConfirmed >= accounting.TotalDue)
-                {
-                    postSaveActions.Add(() => _EventAggregator.Publish(new InvoiceStatusChangedEvent(invoice, "complete")));
-                    invoice.Status = "complete";
-                    needSave = true;
-                }
-            }
-            return (needSave, changes);
-        }
-
-        private async Task<IEnumerable<AccountedPaymentEntity>> GetPaymentsWithTransaction(InvoiceEntity invoice)
-        {
-            var transactions = await _ExplorerClient.GetTransactions(invoice.Payments.Select(t => t.Outpoint.Hash).ToArray());
-
-            var spentTxIn = new Dictionary<OutPoint, AccountedPaymentEntity>();
-            var result = invoice.Payments.Select(p => p.Outpoint).ToHashSet();
-            List<AccountedPaymentEntity> payments = new List<AccountedPaymentEntity>();
-            foreach (var payment in invoice.Payments)
-            {
-                TransactionResult tx;
-                if (!transactions.TryGetValue(payment.Outpoint.Hash, out tx))
-                {
-                    result.Remove(payment.Outpoint);
-                    continue;
-                }
-                AccountedPaymentEntity accountedPayment = new AccountedPaymentEntity()
-                {
-                    Confirmations = tx.Confirmations,
-                    Transaction = tx.Transaction,
-                    Payment = payment
-                };
-                payments.Add(accountedPayment);
-                foreach (var txin in tx.Transaction.Inputs)
-                {
-                    if (!spentTxIn.TryAdd(txin.PrevOut, accountedPayment))
-                    {
-                        //We get a double spend
-                        var existing = spentTxIn[txin.PrevOut];
-
-                        //Take the most recent, the full node is already comparing fees correctly so we have the most likely to be confirmed
-                        if (accountedPayment.Confirmations > 1 || existing.Payment.ReceivedTime < accountedPayment.Payment.ReceivedTime)
-                        {
-                            spentTxIn[txin.PrevOut] = accountedPayment;
-                            result.Remove(existing.Payment.Outpoint);
-                        }
-                    }
-                }
-            }
-
-            List<PaymentEntity> updated = new List<PaymentEntity>();
-            var accountedPayments = payments.Where(p =>
-            {
-                var accounted = result.Contains(p.Payment.Outpoint);
-                if (p.Payment.Accounted != accounted)
-                {
-                    p.Payment.Accounted = accounted;
-                    updated.Add(p.Payment);
-                }
-                return accounted;
-            }).ToArray();
-
-            await _InvoiceRepository.UpdatePayments(payments);
-            return accountedPayments;
-        }
-
-        TimeSpan _PollInterval;
-        public TimeSpan PollInterval
-        {
-            get
-            {
-                return _PollInterval;
-            }
-            set
-            {
-                _PollInterval = value;
-                if (_UpdatePendingInvoices != null)
-                {
-                    _UpdatePendingInvoices.Change(0, (int)value.TotalMilliseconds);
-                }
-            }
-        }
-
-        public void Watch(string invoiceId)
-        {
-            if (invoiceId == null)
-                throw new ArgumentNullException(nameof(invoiceId));
-            _WatchRequests.Add(invoiceId);
-        }
-
-        BlockingCollection<string> _WatchRequests = new BlockingCollection<string>(new ConcurrentQueue<string>());
-
-        public void Dispose()
-        {
-            _Cts.Cancel();
-        }
-
-
-        Thread _Thread;
-        TaskCompletionSource<bool> _RunningTask;
-        CancellationTokenSource _Cts;
-        Timer _UpdatePendingInvoices;
-
-        public Task StartAsync(CancellationToken cancellationToken)
-        {
-            _RunningTask = new TaskCompletionSource<bool>();
-            _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-            _Thread = new Thread(Run) { Name = "InvoiceWatcher" };
-            _Thread.Start();
-            _UpdatePendingInvoices = new Timer(async s =>
-            {
-                foreach (var pending in await _InvoiceRepository.GetPendingInvoices())
-                {
-                    _WatchRequests.Add(pending);
-                }
-            }, null, 0, (int)PollInterval.TotalMilliseconds);
-
-            leases.Add(_EventAggregator.Subscribe<Events.NewBlockEvent>(async b => { await NotifyBlock(); }));
-            leases.Add(_EventAggregator.Subscribe<TxOutReceivedEvent>(async b => { await NotifyReceived(b.ScriptPubKey); }));
-
-            return Task.CompletedTask;
-        }
-
-        void Run()
-        {
-            Logs.PayServer.LogInformation("Start watching invoices");
-            ConcurrentDictionary<string, Lazy<Task>> updating = new ConcurrentDictionary<string, Lazy<Task>>();
-            try
-            {
-                foreach (var item in _WatchRequests.GetConsumingEnumerable(_Cts.Token))
-                {
-                    try
-                    {
-                        _Cts.Token.ThrowIfCancellationRequested();
-                        var localItem = item;
-                        // If the invoice is already updating, ignore
-                        Lazy<Task> updateInvoice = new Lazy<Task>(() => UpdateInvoice(localItem), false);
-                        if (updating.TryAdd(item, updateInvoice))
-                        {
-                            updateInvoice.Value.ContinueWith(i => updating.TryRemove(item, out updateInvoice));
-                        }
-                    }
-                    catch (Exception ex) when (!_Cts.Token.IsCancellationRequested)
-                    {
-                        Logs.PayServer.LogCritical(ex, $"Error in the InvoiceWatcher loop (Invoice {item})");
-                        _Cts.Token.WaitHandle.WaitOne(2000);
-                    }
-                }
-            }
-            catch (OperationCanceledException)
-            {
-                try
-                {
-                    Task.WaitAll(updating.Select(c => c.Value.Value).ToArray());
-                }
-                catch (AggregateException) { }
-                _RunningTask.TrySetResult(true);
-            }
-            finally
-            {
-                Logs.PayServer.LogInformation("Stop watching invoices");
-            }
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken)
-        {
-            leases.Dispose();
-            _UpdatePendingInvoices.Dispose();
-            _Cts.Cancel();
-            return Task.WhenAny(_RunningTask.Task, Task.Delay(-1, cancellationToken));
-        }
-    }
-}

BTCPayServer/Services/Mails/EmailSender.cs

@@ -1,4 +1,6 @@
-using Hangfire;
+using BTCPayServer.Logging;
+using Microsoft.Extensions.Logging;
+using Hangfire;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -20,10 +22,16 @@ namespace BTCPayServer.Services.Mails
             _JobClient = jobClient;
             _Repository = repository;
         }
-        public Task SendEmailAsync(string email, string subject, string message)
+        public async Task SendEmailAsync(string email, string subject, string message)
         {
+            var settings = await _Repository.GetSettingAsync<EmailSettings>();
+            if (settings == null)
+            {
+                Logs.Configuration.LogWarning("Should have sent email, but email settings are not configured");
+                return;
+            }
             _JobClient.Schedule(() => SendMailCore(email, subject, message), TimeSpan.Zero);
-            return Task.CompletedTask;
+            return;
         }
 
         public async Task SendMailCore(string email, string subject, string message)

BTCPayServer/Services/Rates/CachedDefaultRateProviderFactory.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class CachedDefaultRateProviderFactory : IRateProviderFactory
+    {
+        IMemoryCache _Cache;
+        ConcurrentDictionary<string, IRateProvider> _Providers = new ConcurrentDictionary<string, IRateProvider>();
+
+        public IMemoryCache Cache
+        {
+            get
+            {
+                return _Cache;
+            }
+        }
+
+        public CachedDefaultRateProviderFactory(IMemoryCache cache)
+        {
+            if (cache == null)
+                throw new ArgumentNullException(nameof(cache));
+            _Cache = cache;
+        }
+
+        public IRateProvider RateProvider { get; set; }
+
+        public TimeSpan CacheSpan { get; set; } = TimeSpan.FromMinutes(1.0);
+        public IRateProvider GetRateProvider(BTCPayNetwork network)
+        {
+            return _Providers.GetOrAdd(network.CryptoCode, new CachedRateProvider(network.CryptoCode, RateProvider ?? network.DefaultRateProvider, _Cache) { CacheSpan = CacheSpan });
+        }
+    }
+}

BTCPayServer/Services/Rates/CachedRateProvider.cs

@@ -10,15 +10,25 @@ namespace BTCPayServer.Services.Rates
     {
         private IRateProvider _Inner;
         private IMemoryCache _MemoryCache;
+        private string _CryptoCode;
 
-        public CachedRateProvider(IRateProvider inner, IMemoryCache memoryCache)
+        public CachedRateProvider(string cryptoCode, IRateProvider inner, IMemoryCache memoryCache)
         {
             if (inner == null)
                 throw new ArgumentNullException(nameof(inner));
             if (memoryCache == null)
                 throw new ArgumentNullException(nameof(memoryCache));
             this._Inner = inner;
-            this._MemoryCache = memoryCache;
+            this.MemoryCache = memoryCache;
+            this._CryptoCode = cryptoCode;
+        }
+
+        public IRateProvider Inner
+        {
+            get
+            {
+                return _Inner;
+            }
         }
 
         public TimeSpan CacheSpan
@@ -26,29 +36,26 @@ namespace BTCPayServer.Services.Rates
             get;
             set;
         } = TimeSpan.FromMinutes(1.0);
+        public IMemoryCache MemoryCache { get => _MemoryCache; private set => _MemoryCache = value; }
 
         public Task<decimal> GetRateAsync(string currency)
         {
-            return _MemoryCache.GetOrCreateAsync("CURR_" + currency, (ICacheEntry entry) =>
+            return MemoryCache.GetOrCreateAsync("CURR_" + currency + "_" + _CryptoCode + "_" + AdditionalScope, (ICacheEntry entry) =>
             {
                 entry.AbsoluteExpiration = DateTimeOffset.UtcNow + CacheSpan;
                 return _Inner.GetRateAsync(currency);
             });
         }
-
-        private bool TryGetFromCache(string key, out object obj)
-        {
-            obj = _MemoryCache.Get(key);
-            return obj != null;
-        }
-
+        
         public Task<ICollection<Rate>> GetRatesAsync()
         {
-            return _MemoryCache.GetOrCreateAsync("GLOBAL_RATES", (ICacheEntry entry) =>
+            return MemoryCache.GetOrCreateAsync("GLOBAL_RATES_" + _CryptoCode + "_" + AdditionalScope, (ICacheEntry entry) =>
             {
                 entry.AbsoluteExpiration = DateTimeOffset.UtcNow + CacheSpan;
                 return _Inner.GetRatesAsync();
             });
         }
+
+        public string AdditionalScope { get; set; }
     }
 }

BTCPayServer/Services/Rates/CoinAverageRateProvider.cs

@@ -19,6 +19,15 @@ namespace BTCPayServer.Services.Rates
     {
         static HttpClient _Client = new HttpClient();
 
+        public CoinAverageRateProvider(string cryptoCode)
+        {
+            CryptoCode = cryptoCode ?? "BTC";
+        }
+
+        public string Exchange { get; set; }
+
+        public string CryptoCode { get; set; }
+
         public string Market
         {
             get; set;
@@ -38,7 +47,15 @@ namespace BTCPayServer.Services.Rates
 
         private async Task<Dictionary<string, decimal>> GetRatesCore()
         {
-            var resp = await _Client.GetAsync($"https://apiv2.bitcoinaverage.com/indices/{Market}/ticker/short");
+            HttpResponseMessage resp = null;
+            if (Exchange == null)
+            {
+                resp = await _Client.GetAsync($"https://apiv2.bitcoinaverage.com/indices/{Market}/ticker/short");
+            }
+            else
+            {
+                resp = await _Client.GetAsync($"https://apiv2.bitcoinaverage.com/exchanges/{Exchange}");
+            }
             using (resp)
             {
 
@@ -50,9 +67,23 @@ namespace BTCPayServer.Services.Rates
                     throw new CoinAverageException("Unauthorized access to the API, premium plan needed");
                 resp.EnsureSuccessStatusCode();
                 var rates = JObject.Parse(await resp.Content.ReadAsStringAsync());
+                if(Exchange != null)
+                {
+                    rates = (JObject)rates["symbols"];
+                }
                 return rates.Properties()
-                              .Where(p => p.Name.StartsWith("BTC", StringComparison.OrdinalIgnoreCase))
-                              .ToDictionary(p => p.Name.Substring(3, 3), p => ToDecimal(p.Value["last"]));
+                              .Where(p => p.Name.StartsWith(CryptoCode, StringComparison.OrdinalIgnoreCase))
+                              .ToDictionary(p => p.Name.Substring(CryptoCode.Length, p.Name.Length - CryptoCode.Length), p =>
+                              {
+                                  if (Exchange == null)
+                                  {
+                                      return ToDecimal(p.Value["last"]);
+                                  }
+                                  else
+                                  {
+                                      return ToDecimal(p.Value["bid"]);
+                                  }
+                              });
             }
         }
 

BTCPayServer/Services/Rates/IRateProviderFactory.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Services.Rates
+{
+    public interface IRateProviderFactory
+    {
+        IRateProvider GetRateProvider(BTCPayNetwork network);
+    }
+}

BTCPayServer/Services/Rates/MockRateProvider.cs

@@ -6,17 +6,38 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Services.Rates
 {
+    public class MockRateProviderFactory : IRateProviderFactory
+    {
+        List<MockRateProvider> _Mocks = new List<MockRateProvider>();
+        public MockRateProviderFactory()
+        {
+
+        }
+
+        public void AddMock(MockRateProvider mock)
+        {
+            _Mocks.Add(mock);
+        }
+        public IRateProvider GetRateProvider(BTCPayNetwork network)
+        {
+            return _Mocks.FirstOrDefault(m => m.CryptoCode == network.CryptoCode);
+        }
+    }
     public class MockRateProvider : IRateProvider
     {
         List<Rate> _Rates;
 
-        public MockRateProvider(params Rate[] rates)
+        public string CryptoCode { get; }
+
+        public MockRateProvider(string cryptoCode, params Rate[] rates)
         {
             _Rates = new List<Rate>(rates);
+            CryptoCode = cryptoCode;
         }
-        public MockRateProvider(List<Rate> rates)
+        public MockRateProvider(string cryptoCode, List<Rate> rates)
         {
             _Rates = rates;
+            CryptoCode = cryptoCode;
         }
         public Task<decimal> GetRateAsync(string currency)
         {

BTCPayServer/Services/Rates/TweakRateProvider.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class TweakRateProvider : IRateProvider
+    {
+        private BTCPayNetwork network;
+        private IRateProvider rateProvider;
+        private List<RateRule> rateRules;
+
+        public TweakRateProvider(BTCPayNetwork network, IRateProvider rateProvider, List<RateRule> rateRules)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            if (rateProvider == null)
+                throw new ArgumentNullException(nameof(rateProvider));
+            if (rateRules == null)
+                throw new ArgumentNullException(nameof(rateRules));
+            this.network = network;
+            this.rateProvider = rateProvider;
+            this.rateRules = rateRules;
+        }
+
+        public async Task<decimal> GetRateAsync(string currency)
+        {
+            var rate = await rateProvider.GetRateAsync(currency);
+            foreach(var rule in rateRules)
+            {
+                rate = rule.Apply(network, rate);
+            }
+            return rate;
+        }
+
+        public async Task<ICollection<Rate>> GetRatesAsync()
+        {
+            List<Rate> rates = new List<Rate>();
+            foreach (var rate in await rateProvider.GetRatesAsync())
+            {
+                var localRate = rate.Value;
+                foreach (var rule in rateRules)
+                {
+                    localRate = rule.Apply(network, localRate);
+                }
+                rates.Add(new Rate(rate.Currency, localRate));
+            }
+            return rates;
+        }
+    }
+}

BTCPayServer/Services/Stores/StoreRepository.cs

@@ -68,7 +68,8 @@ namespace BTCPayServer.Services.Stores
                 StoreData store = new StoreData
                 {
                     Id = Encoders.Base58.EncodeData(RandomUtils.GetBytes(32)),
-                    StoreName = name
+                    StoreName = name,
+                    SpeedPolicy = Invoices.SpeedPolicy.MediumSpeed
                 };
                 var userStore = new UserStore
                 {

BTCPayServer/Services/TransactionCache.cs

@@ -0,0 +1,96 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+using NBitcoin;
+using NBXplorer.Models;
+
+namespace BTCPayServer.Services
+{
+    public class TransactionCacheProvider
+    {
+        IOptions<MemoryCacheOptions> _Options;
+        public TransactionCacheProvider(IOptions<MemoryCacheOptions> options)
+        {
+            _Options = options;
+        }
+
+        ConcurrentDictionary<string, TransactionCache> _TransactionCaches = new ConcurrentDictionary<string, TransactionCache>();
+        public TransactionCache GetTransactionCache(BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            return _TransactionCaches.GetOrAdd(network.CryptoCode, c => new TransactionCache(_Options, network));
+        }
+    }
+    public class TransactionCache : IDisposable
+    {
+        //IOptions<MemoryCacheOptions> _Options;
+        public TransactionCache(IOptions<MemoryCacheOptions> options, BTCPayNetwork network)
+        {
+            //if (network == null)
+            //    throw new ArgumentNullException(nameof(network));
+            //_Options = options;
+            //_MemoryCache = new MemoryCache(_Options);
+            //Network = network;
+        }
+
+        //uint256 _LastHash;
+        //int _ConfOffset;
+        //IMemoryCache _MemoryCache;
+        
+        public void NewBlock(uint256 newHash, uint256 previousHash)
+        {
+            //if (_LastHash != previousHash)
+            //{
+            //    var old = _MemoryCache;
+            //    _ConfOffset = 0;
+            //    _MemoryCache = new MemoryCache(_Options);
+            //    Thread.MemoryBarrier();
+            //    old.Dispose();
+            //}
+            //else
+            //    _ConfOffset++;
+            //_LastHash = newHash;
+        }
+
+        public TimeSpan CacheSpan { get; private set; } = TimeSpan.FromMinutes(60);
+
+        public BTCPayNetwork Network { get; private set; }
+
+        public void AddToCache(TransactionResult tx)
+        {
+            //Logging.Logs.PayServer.LogInformation($"ADD CACHE: {tx.Transaction.GetHash()} ({tx.Confirmations} conf)");
+            //_MemoryCache.Set(tx.Transaction.GetHash(), tx, DateTimeOffset.UtcNow + CacheSpan);
+        }
+
+
+        public TransactionResult GetTransaction(uint256 txId)
+        {
+            //var ok = _MemoryCache.TryGetValue(txId.ToString(), out object tx);
+            //Logging.Logs.PayServer.LogInformation($"GET CACHE: {txId} ({ok} plus {_ConfOffset})");
+
+            //var result = tx as TransactionResult;
+            //var confOffset = _ConfOffset;
+            //if (result != null && result.Confirmations > 0 && confOffset > 0)
+            //{
+            //    var serializer = new NBXplorer.Serializer(Network.NBitcoinNetwork);
+            //    result = serializer.ToObject<TransactionResult>(serializer.ToString(result));
+            //    result.Confirmations += confOffset;
+            //    result.Height += confOffset;
+            //}
+            //return result;
+            return null; // Does not work correctly yet
+        }
+
+        public void Dispose()
+        {
+            //_MemoryCache.Dispose();
+        }
+    }
+}

BTCPayServer/Services/Wallets/BTCPayWallet.cs

@@ -7,31 +7,65 @@ using System.Text;
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
+using System.Threading;
+using NBXplorer.Models;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace BTCPayServer.Services.Wallets
 {
+    public class KnownState
+    {
+        public UTXOChanges PreviousCall { get; set; }
+    }
+    public class NetworkCoins
+    {
+        public class TimestampedCoin
+        {
+            public DateTimeOffset DateTime { get; set; }
+            public Coin Coin { get; set; }
+        }
+        public TimestampedCoin[] TimestampedCoins { get; set; }
+        public KnownState State { get; set; }
+        public DerivationStrategyBase Strategy { get; set; }
+        public BTCPayWallet Wallet { get; set; }
+    }
     public class BTCPayWallet
     {
         private ExplorerClient _Client;
-        private Serializer _Serializer;
-        ApplicationDbContextFactory _DBFactory;
-
-        public BTCPayWallet(ExplorerClient client, ApplicationDbContextFactory factory)
+        private TransactionCache _Cache;
+        public BTCPayWallet(ExplorerClient client, TransactionCache cache, BTCPayNetwork network)
         {
             if (client == null)
                 throw new ArgumentNullException(nameof(client));
-            if (factory == null)
-                throw new ArgumentNullException(nameof(factory));
             _Client = client;
-            _DBFactory = factory;
-            _Serializer = new NBXplorer.Serializer(_Client.Network);
+            _Network = network;
+            _Cache = cache;
         }
 
 
+        private readonly BTCPayNetwork _Network;
+        public BTCPayNetwork Network
+        {
+            get
+            {
+                return _Network;
+            }
+        }
+
+        public TimeSpan CacheSpan { get; private set; } = TimeSpan.FromMinutes(60);
+
         public async Task<BitcoinAddress> ReserveAddressAsync(DerivationStrategyBase derivationStrategy)
         {
+            if (derivationStrategy == null)
+                throw new ArgumentNullException(nameof(derivationStrategy));
             var pathInfo = await _Client.GetUnusedAsync(derivationStrategy, DerivationFeature.Deposit, 0, true).ConfigureAwait(false);
-            return pathInfo.ScriptPubKey.GetDestinationAddress(_Client.Network);
+            // Might happen on some broken install
+            if (pathInfo == null)
+            {
+                await _Client.TrackAsync(derivationStrategy).ConfigureAwait(false);
+                pathInfo = await _Client.GetUnusedAsync(derivationStrategy, DerivationFeature.Deposit, 0, true).ConfigureAwait(false);
+            }
+            return pathInfo.ScriptPubKey.GetDestinationAddress(Network.NBitcoinNetwork);
         }
 
         public async Task TrackAsync(DerivationStrategyBase derivationStrategy)
@@ -39,9 +73,28 @@ namespace BTCPayServer.Services.Wallets
             await _Client.TrackAsync(derivationStrategy);
         }
 
-        private byte[] ToBytes<T>(T obj)
+        public async Task<TransactionResult> GetTransactionAsync(uint256 txId, CancellationToken cancellation = default(CancellationToken))
         {
-            return ZipUtils.Zip(_Serializer.ToString(obj));
+            if (txId == null)
+                throw new ArgumentNullException(nameof(txId));
+            var tx = _Cache.GetTransaction(txId);
+            if (tx != null)
+                return tx;
+            tx = await _Client.GetTransactionAsync(txId, cancellation);
+            _Cache.AddToCache(tx);
+            return tx;
+        }
+
+        public async Task<NetworkCoins> GetCoins(DerivationStrategyBase strategy, KnownState state, CancellationToken cancellation = default(CancellationToken))
+        {
+            var changes = await _Client.GetUTXOsAsync(strategy, state?.PreviousCall, false, cancellation).ConfigureAwait(false);
+            return new NetworkCoins()
+            {
+                TimestampedCoins = changes.Confirmed.UTXOs.Concat(changes.Unconfirmed.UTXOs).Select(c => new NetworkCoins.TimestampedCoin() { Coin = c.AsCoin(), DateTime = c.Timestamp }).ToArray(),
+                State = new KnownState() { PreviousCall = changes },
+                Strategy = strategy,
+                Wallet = this
+            };
         }
 
         public Task BroadcastTransactionsAsync(List<Transaction> transactions)
@@ -50,12 +103,21 @@ namespace BTCPayServer.Services.Wallets
             return Task.WhenAll(tasks);
         }
 
+
         public async Task<Money> GetBalance(DerivationStrategyBase derivationStrategy)
         {
-            var result = await _Client.SyncAsync(derivationStrategy, null, true);
-            return result.Confirmed.UTXOs.Select(u => u.Value)
-                         .Concat(result.Unconfirmed.UTXOs.Select(u => u.Value))
-                         .Sum();
+            var result = await _Client.GetUTXOsAsync(derivationStrategy, null, true);
+
+            Dictionary<OutPoint, UTXO> received = new Dictionary<OutPoint, UTXO>();
+            foreach(var utxo in result.Confirmed.UTXOs.Concat(result.Unconfirmed.UTXOs))
+            {
+                received.TryAdd(utxo.Outpoint, utxo);
+            }
+            foreach (var utxo in result.Confirmed.SpentOutpoints.Concat(result.Unconfirmed.SpentOutpoints))
+            {
+                received.Remove(utxo);
+            }
+            return received.Values.Select(c => c.Value).Sum();
         }
     }
 }

BTCPayServer/Services/Wallets/BTCPayWalletProvider.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace BTCPayServer.Services.Wallets
+{
+    public class BTCPayWalletProvider
+    {
+        private ExplorerClientProvider _Client;
+        BTCPayNetworkProvider _NetworkProvider;
+        TransactionCacheProvider _TransactionCacheProvider;
+        public BTCPayWalletProvider(ExplorerClientProvider client,
+                                    TransactionCacheProvider transactionCacheProvider,
+                                    BTCPayNetworkProvider networkProvider)
+        {
+            if (client == null)
+                throw new ArgumentNullException(nameof(client));
+            _Client = client;
+            _TransactionCacheProvider = transactionCacheProvider;
+            _NetworkProvider = networkProvider;
+        }
+
+        public BTCPayWallet GetWallet(BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            return GetWallet(network.CryptoCode);
+        }
+        public BTCPayWallet GetWallet(string cryptoCode)
+        {
+            if (cryptoCode == null)
+                throw new ArgumentNullException(nameof(cryptoCode));
+            var network = _NetworkProvider.GetNetwork(cryptoCode);
+            var client = _Client.GetExplorerClient(cryptoCode);
+            if (network == null || client == null)
+                return null;
+            return new BTCPayWallet(client, _TransactionCacheProvider.GetTransactionCache(network), network);
+        }
+
+        public bool IsAvailable(BTCPayNetwork network)
+        {
+            return _Client.IsAvailable(network);
+        }
+    }
+}

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/xh3Eac66qc4" frameborder="0" allowfullscreen></iframe>
+                <iframe width="400" height="225" 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/Xo_vApXTZBU" frameborder="0" allowfullscreen></iframe>
+                <iframe width="400" height="225" src="https://www.youtube.com/embed/Xo_vApXTZBU" frameborder="0" allowfullscreen></iframe>
             </div>
         </div>
     </div>
@@ -122,10 +122,10 @@
         </div>
         <div class="row">
             <div class="col-lg-4 ml-auto text-center">
-                <a href="http://52.191.212.129:3000/">
+                <a href="http://slack.forkbitpay.ninja/">
                     <img src="~/img/slack.png" height="100" />
                 </a>
-                <p><a href="http://52.191.212.129:3000/">On Slack</a></p>
+                <p><a href="http://slack.forkbitpay.ninja/">On Slack</a></p>
             </div>
             <div class="col-lg-4 mr-auto text-center">
                 <a href="https://twitter.com/BtcpayServer">

BTCPayServer/Views/Invoice/Checkout.cshtml

@@ -21,7 +21,7 @@
 		@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>
+    <script src="~/js/vue.min.js" type="text/javascript" defer="defer"></script>
     <script src="~/js/vue-qrcode.js" type="text/javascript" defer="defer"></script>
     <script src="~/js/core.js" type="text/javascript" defer="defer"></script>
     <!-- <script src="img/Intl.js" type="text/javascript" defer="defer"></script>
@@ -106,11 +106,11 @@
                                         <!---->
                                         <div class="single-item-order__right">
                                             <div class="single-item-order__right__btc-price" id="buyerTotalBtcAmount">
-                                                <span>{{ srvModel.btcDue }} BTC</span>
+                                                <span>{{ srvModel.btcDue }} {{ srvModel.cryptoCode }}</span>
                                             </div>
                                             <!---->
                                             <div class="single-item-order__right__ex-rate">
-                                                1 BTC = {{ srvModel.rate }}
+                                                1 {{ srvModel.cryptoCode }} = {{ srvModel.rate }}
                                             </div>
                                             <!---->
                                         </div>
@@ -123,24 +123,24 @@
                                         <div class="line-items">
                                             <!---->
                                             <div class="line-items__item">
-                                                <div class="line-items__item__label" i18n="">Payment Amount</div>
-                                                <div class="line-items__item__value">{{srvModel.btcAmount}} BTC</div>
+                                                <div class="line-items__item__label" i18n="">Order Amount</div>
+                                                <div class="line-items__item__value">{{srvModel.orderAmount}} {{ srvModel.cryptoCode }}</div>
                                             </div>
                                             <div class="line-items__item">
                                                 <div class="line-items__item__label">
                                                     <span i18n="">Network Cost</span>
                                                 </div>
-                                                <div class="line-items__item__value" i18n="">{{srvModel.txCount }} transaction x {{ srvModel.txFees}} BTC</div>
+                                                <div class="line-items__item__value" i18n="">{{srvModel.networkFeeDescription }}</div>
                                             </div>
                                             <div class="line-items__item">
                                                 <div class="line-items__item__label">
                                                     <span i18n="">Already Paid</span>
                                                 </div>
-                                                <div class="line-items__item__value" i18n="">-{{srvModel.btcPaid }} BTC</div>
+                                                <div class="line-items__item__value" i18n="">-{{srvModel.btcPaid }} {{ srvModel.cryptoCode }}</div>
                                             </div>
                                             <div class="line-items__item line-items__item--total">
                                                 <div class="line-items__item__label" i18n="">Due	</div>
-                                                <div class="line-items__item__value">{{srvModel.btcDue}} BTC</div>
+                                                <div class="line-items__item__value">{{srvModel.btcDue}} {{ srvModel.cryptoCode }}</div>
                                             </div>
                                             <!---->
                                         </div>
@@ -158,7 +158,8 @@
                                 <div adjust-height="" class="payment-box">
                                     <div class="bp-view payment scan" id="scan">
                                         <div class="payment__scan">
-                                            <qrcode :val="srvModel.btcAddress" :size="256" bg-color="#f5f5f7" fg-color="#000" />
+                                            <img :src="srvModel.cryptoImage" style="position: absolute; height:64px; width:64px; left:118px; top:96px;" />
+                                            <qrcode :val="srvModel.invoiceBitcoinUrl" :size="256" bg-color="#f5f5f7" fg-color="#000" />
                                         </div>
                                         <div class="payment__details__instruction__open-wallet">
                                             <a class="payment__details__instruction__open-wallet__btn action-button" v-bind:href="srvModel.invoiceBitcoinUrl">
@@ -311,7 +312,7 @@
                                                 <bp-refund-address name="refundAddress" ngmodel="" class="ng-untouched ng-pristine ng-invalid">
                                                     <div class="bp-refund-address">
                                                         <div class="bitcoin-logo">
-                                                            <div><img src="~/imlegacy/bitcoin-symbol.svg"></div>
+                                                            <div><img src="@Model.CryptoImage"></div>
                                                         </div>
                                                         <input class="bp-input {'not-empty': addressValue.length &gt; 0} ng-untouched ng-pristine ng-valid" id="refund-address-input" name="refundAddress" ngclass="{'not-empty': addressValue.length &gt; 0}">
                                                     </div>
@@ -336,14 +337,14 @@
                                     </div>
                                     <div class="bp-view payment manual-flow" id="copy">
                                         <div class="manual__step-two__instructions">
-                                            <span i18n="">To complete your payment, please send {{ srvModel.btcDue }} BTC to the address below.</span>
+                                            <span i18n="">To complete your payment, please send {{ srvModel.btcDue }} {{ srvModel.cryptoCode }} to the address below.</span>
                                         </div>
                                         <div class="manual-box flipped" style="margin-bottom: 30px;">
                                             <div class="manual-box__amount">
                                                 <div class="manual-box__amount__label label" i18n="">Amount</div>
                                                 <!---->
                                                 <div class="manual-box__amount__value copy-cursor" ngxclipboard="">
-                                                    <span>{{srvModel.btcDue}}</span> BTC
+                                                    <span>{{srvModel.btcDue}}</span> {{ srvModel.cryptoCode }}
                                                     <div class="copied-label">
                                                         <span i18n="">Copied</span>
                                                     </div>
@@ -360,7 +361,7 @@
                                                         <div class="manual-box__address__value copy-cursor" ngxclipboard="">
                                                             <div class="manual-box__address__wrapper">
                                                                 <div class="manual-box__address__wrapper__logo">
-                                                                    <img src="~/imlegacy/bitcoin-symbol.svg">
+                                                                    <img :src="srvModel.cryptoImage" />
                                                                 </div>
                                                                 <div class="manual-box__address__wrapper__value">{{srvModel.btcAddress}}</div>
                                                             </div>
@@ -491,7 +492,7 @@
                                         <div>
                                             <div class="expired__body">
                                                 <div class="expired__header" i18n="">What happened?</div>
-                                                <div class="expired__text" i18n="">This invoice has expired. An invoice is only valid for 15 minutes. You can <div class="expired__text__link i18n-return-to-merchant">return to {{srvModel.storeName}}</div> if you would like to submit your payment again.</div>
+                                                <div class="expired__text" i18n="">This invoice has expired. An invoice is only valid for @Model.MaxTimeMinutes minutes. You can <div class="expired__text__link i18n-return-to-merchant">return to {{srvModel.storeName}}</div> if you would like to submit your payment again.</div>
                                                 <div class="expired__text" i18n="">If you tried to send a payment, it has not yet been accepted by the Bitcoin network. We have not yet received your funds.</div>
                                                 <div class="expired__text" i18n="">
                                                     If the transaction
@@ -503,7 +504,7 @@
                                                     <span class="expired__text__bullet" i18n="">Invoice ID:</span> {{srvModel.invoiceId}}<br>
                                                     <!---->
                                                     <span>
-                                                        <span class="expired__text__bullet" i18n="">Order ID:</span> {{srvModel.OrderId}}
+                                                        <span class="expired__text__bullet" i18n="">Order ID:</span> {{srvModel.orderId}}
                                                     </span>
                                                 </div>
                                             </div>
@@ -605,8 +606,17 @@
                         </div>
                     </div>
                     <div class="footer">
-                        <div class="footer__item no-hover" style="opacity: 1; padding-left: 0; max-height: 21px; display: none;">
-                            <div></div>
+                        <div class="footer__item no-hover" style="opacity: 1; padding-left: 0; max-height: 21px;">
+                            @if(Model.AvailableCryptos.Count > 1)
+                            {
+                                <div style="text-align:center">Accepted here</div>
+                                <div style="text-align:center">
+                                    @foreach(var crypto in Model.AvailableCryptos)
+                                    {
+                                        <a style="text-decoration:none;" href="@crypto.Link" onclick="srvModel.cryptoCode='@crypto.CryptoCode'; fetchStatus(); return false;"><img style="height:32px; margin-right:5px; margin-left:5px;" alt="@crypto.CryptoCode" src="@crypto.CryptoImage" /></a>
+                                    }
+                                </div>
+                            }
                         </div>
                     </div>
                 </div>

BTCPayServer/Views/Invoice/Invoice.cshtml

@@ -49,10 +49,22 @@
                         <th>Expiration date</th>
                         <td>@Model.ExpirationDate</td>
                     </tr>
+                    <tr>
+                        <th>Monitoring date</th>
+                        <td>@Model.MonitoringDate</td>
+                    </tr>
+                    <tr>
+                        <th>Transaction speed</th>
+                        <td>@Model.TransactionSpeed</td>
+                    </tr>
                     <tr>
                         <th>Status</th>
                         <td>@Model.Status</td>
                     </tr>
+                    <tr>
+                        <th>Status Exception</th>
+                        <td>@Model.StatusException</td>
+                    </tr>
                     <tr>
                         <th>Refund email</th>
                         <td>@Model.RefundEmail</td>
@@ -61,41 +73,17 @@
                         <th>Order Id</th>
                         <td>@Model.OrderId</td>
                     </tr>
-                    <tr>
-                        <th>Rate</th>
-                        <td>@Model.Rate</td>
-                    </tr>
                     <tr>
                         <th>Total fiat due</th>
                         <td>@Model.Fiat</td>
                     </tr>
-                    <tr>
-                        <th>Network Fee</th>
-                        <td>@Model.NetworkFee</td>
-                    </tr>
-                    <tr>
-                        <th>Total crypto due</th>
-                        <td>@Model.BTC</td>
-                    </tr>
-                    <tr>
-                        <th>Crypto due</th>
-                        <td>@Model.BTCDue</td>
-                    </tr>
-                    <tr>
-                        <th>Crypto paid</th>
-                        <td>@Model.BTCPaid</td>
-                    </tr>
                     <tr>
                         <th>Notification Url</th>
                         <td>@Model.NotificationUrl</td>
                     </tr>
                     <tr>
-                        <th>Payment address</th>
-                        <td>@Model.BitcoinAddress</td>
-                    </tr>
-                    <tr>
-                        <th>Payment Url</th>
-                        <td class="overflowbox"><a href="@Model.PaymentUrl">@Model.PaymentUrl</a></td>
+                        <th>Redirect Url</th>
+                        <td>@Model.RedirectUrl</td>
                     </tr>
                 </table>
             </div>
@@ -161,31 +149,103 @@
         </div>
         <div class="row">
             <div class="col-md-12">
-                <h3>Payments</h3>
-                <div class="form-group">
-                    <form asp-action="Invoice" method="post">
-                        <button type="submit" name="command" class="btn btn-success" value="refresh" title="Refresh State">
-                            Refresh state
-                        </button>
-                    </form>
-                </div>
+                <h3>Paid summary</h3>
                 <table class="table">
                     <thead class="thead-inverse">
                         <tr>
+                            <th>Crypto</th>
+                            <th>Rate</th>
+                            <th>Paid</th>
+                            <th>Due</th>
+                            <th>Address</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        @foreach(var payment in Model.CryptoPayments)
+                    {
+                        <tr>
+                            <td>@payment.CryptoCode</td>
+                            <td>@payment.Rate</td>
+                            <td>@payment.Paid</td>
+                            <td>@payment.Due</td>
+                            <td>@payment.Address</td>
+                        </tr>
+                }
+                    </tbody>
+                </table>
+            </div>
+        </div>
+        <div class="row">
+            <div class="col-md-12">
+                <h3>Payments</h3>
+                <table class="table">
+                    <thead class="thead-inverse">
+                        <tr>
+                            <th>Crypto</th>
                             <th>Date</th>
                             <th>Deposit address</th>
                             <th>Transaction Id</th>
                             <th>Confirmations</th>
+                            <th>Replaced</th>
                         </tr>
                     </thead>
                     <tbody>
                         @foreach(var payment in Model.Payments)
+                    {
+                        <tr>
+                            <td>@payment.CryptoCode</td>
+                            <td>@payment.ReceivedTime</td>
+                            <td>@payment.DepositAddress</td>
+                            <td><a href="@payment.TransactionLink" target="_blank">@payment.TransactionId</a></td>
+                            <td>@payment.Confirmations</td>
+                            <td>@payment.Replaced</td>
+                        </tr>
+                }
+                    </tbody>
+                </table>
+            </div>
+        </div>
+        <div class="row">
+            <div class="col-md-12">
+                <h3>Addresses</h3>
+                <table class="table">
+                    <thead class="thead-inverse">
+                        <tr>
+                            <th>Crypto</th>
+                            <th>Address</th>
+                            <th>Current</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        @foreach(var address in Model.Addresses)
+                    {
+                        <tr>
+                            <td>@address.GetCryptoCode()</td>
+                            <td>@address.GetAddress()</td>
+                            <td>@(!address.UnAssigned.HasValue)</td>
+                        </tr>
+                }
+                    </tbody>
+                </table>
+            </div>
+        </div>
+
+        <div class="row">
+            <div class="col-md-12">
+                <h3>Events</h3>
+                <table class="table">
+                    <thead class="thead-inverse">
+                        <tr>
+                            <th>Date</th>
+                            <th>Message</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        @foreach(var evt in Model.Events)
                         {
                             <tr>
-                                <td>@payment.ReceivedTime</td>
-                                <td>@payment.DepositAddress</td>
-                                <td><a href="@payment.TransactionLink" target="_blank">@payment.TransactionId</a></td>
-                                <td>@payment.Confirmations</td>
+                                <td>@evt.Timestamp</td>
+                                <td>@evt.Message</td>
                             </tr>
                         }
                     </tbody>

BTCPayServer/Views/Shared/SyncModal.cshtml

@@ -0,0 +1,94 @@
+@inject BTCPayServer.HostedServices.NBXplorerDashboard dashboard
+<!-- Modal -->
+<div id="modalDialog" class="modal-dialog animated bounceInRight">
+
+    <!-- Modal content-->
+    <div class="modal-content">
+        <div class="modal-header">
+            <h4 class="modal-title">Your nodes are synching...</h4>
+            <button type="button" class="close" onclick="dismissSyncModal()">&times;</button>
+        </div>
+        <div class="modal-body">
+            <p>
+                Some of your nodes are still synching...<br />
+                BTCPay Server will not work correctly until it is over.
+            </p>
+            @foreach (var line in dashboard.GetAll())
+            {
+                <h4>@line.Network.CryptoCode</h4>
+                @if (line.Status == null)
+                {
+                    <ul>
+                        <li>The node is offline</li>
+                        @if (line.Error != null)
+                        {
+                            <li>Last error: @line.Error</li>
+                        }
+                    </ul>
+                }
+                else
+                {
+                    <ul>
+                        <li>NBXplorer headers height: @line.Status.ChainHeight</li>
+                        @if (line.Status.BitcoinStatus == null)
+                        {
+                            if (line.State == BTCPayServer.HostedServices.NBXplorerState.Synching)
+                            {
+                                <li>The node is starting...</li>
+                            }
+                            else
+                            {
+                                <li>The node is offline</li>
+                                @if (line.Error != null)
+                                {
+                                    <li>Last error: @line.Error</li>
+                                }
+                            }
+                        }
+                        else if (line.Status.BitcoinStatus.IsSynched)
+                        {
+                            <li>The node is synched (Height: @line.Status.BitcoinStatus.Headers)</li>
+                            @if (line.Status.BitcoinStatus.IsSynched &&
+                                line.Status.SyncHeight.HasValue &&
+                                line.Status.SyncHeight.Value < line.Status.BitcoinStatus.Headers)
+                            {
+                                <li>NBXplorer is synching... (Height: @line.Status.SyncHeight.Value)</li>
+                            }
+                        }
+                        else
+                        {
+                            <li>Node headers height: @line.Status.BitcoinStatus.Headers</li>
+                            <li>Validated blocks: @line.Status.BitcoinStatus.Blocks</li>
+                        }
+                    </ul>
+                    @if (!line.Status.IsFullySynched && line.Status.BitcoinStatus != null)
+                    {
+                        <div class="progress">
+                            <div class="progress-bar" role="progressbar" aria-valuenow="@((int)(line.Status.BitcoinStatus.VerificationProgress * 100))"
+                                 aria-valuemin="0" aria-valuemax="100" style="width:@((int)(line.Status.BitcoinStatus.VerificationProgress * 100))%">
+                                @((int)(line.Status.BitcoinStatus.VerificationProgress * 100))%
+                            </div>
+                        </div>
+                    }
+                }
+            }
+        </div>
+    </div>
+
+</div>
+
+<link href="~/vendor/animatecss/animate.css" rel="stylesheet" />
+<script type="text/javascript">
+    function dismissSyncModal() {
+        $("#modalDialog").addClass('animated bounceOutRight')
+    }
+</script>
+
+<style type="text/css">
+    #modalDialog {
+        position: fixed;
+        bottom: 20px;
+        right: 20px;
+        margin: 0px;
+    }
+</style>

BTCPayServer/Views/Shared/_Layout.cshtml

@@ -2,12 +2,7 @@
 @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;
-}
+@inject BTCPayServer.HostedServices.NBXplorerDashboard dashboard
 
 <!DOCTYPE html>
 <html lang="en">
@@ -43,7 +38,7 @@
 <body id="page-top">
 
     @{
-        if(ViewBag.AlwaysShrinkNavBar == null)
+        if (ViewBag.AlwaysShrinkNavBar == null)
         {
             ViewBag.AlwaysShrinkNavBar = true;
         }
@@ -53,30 +48,36 @@
     <!-- Navigation -->
     <nav class='navbar navbar-expand-lg navbar-light fixed-top @additionalStyle' id="mainNav">
         <div class="container">
-            <a class="navbar-brand js-scroll-trigger" href="~/"><img src="~/img/logo.png" height="45"></a>
+            <a class="navbar-brand js-scroll-trigger" href="~/">
+                <img src="~/img/logo.png" height="45">
+                @if(env.ChainType != NBXplorer.ChainType.Main)
+                {
+                <span class="badge badge-warning" style="font-size:10px;">@env.ChainType.ToString()</span>
+                }
+            </a>
             <button class="navbar-toggler navbar-toggler-right" type="button" data-toggle="collapse" data-target="#navbarResponsive" aria-controls="navbarResponsive" aria-expanded="false" aria-label="Toggle navigation">
                 <span class="navbar-toggler-icon"></span>
             </button>
             <div class="collapse navbar-collapse" id="navbarResponsive">
                 <ul class="navbar-nav ml-auto">
                     @if(SignInManager.IsSignedIn(User))
-                    {
-                        @if(User.IsInRole(Roles.ServerAdmin))
-                        {
-                            <li class="nav-item"><a asp-area="" asp-controller="Server" asp-action="ListUsers" class="nav-link js-scroll-trigger">Server settings</a></li>
-                        }
-                        <li class="nav-item"><a asp-area="" asp-controller="Stores" asp-action="ListStores" class="nav-link js-scroll-trigger">Stores</a></li>
-                        <li class="nav-item"><a asp-area="" asp-controller="Invoice" asp-action="ListInvoices" class="nav-link js-scroll-trigger">Invoices</a></li>
-                        <li class="nav-item">
-                            <a asp-area="" asp-controller="Manage" asp-action="Index" title="Manage" class="nav-link js-scroll-trigger">My settings</a>
-                        </li>
-                        <li class="nav-item">
-                            <a asp-area="" asp-controller="Account" asp- asp-action="Logout" title="Manage" class="nav-link js-scroll-trigger">Log out</a>
-                        </li>}
-                    else
-                    {
-                        <li class="nav-item"><a asp-area="" asp-controller="Account" asp-action="Register" class="nav-link js-scroll-trigger">Register</a></li>
-                        <li class="nav-item"><a asp-area="" asp-controller="Account" asp-action="Login" class="nav-link js-scroll-trigger">Log in</a></li>}
+            {
+                @if(User.IsInRole(Roles.ServerAdmin))
+        {
+            <li class="nav-item"><a asp-area="" asp-controller="Server" asp-action="ListUsers" class="nav-link js-scroll-trigger">Server settings</a></li>
+}
+                <li class="nav-item"><a asp-area="" asp-controller="Stores" asp-action="ListStores" class="nav-link js-scroll-trigger">Stores</a></li>
+                <li class="nav-item"><a asp-area="" asp-controller="Invoice" asp-action="ListInvoices" class="nav-link js-scroll-trigger">Invoices</a></li>
+                <li class="nav-item">
+                    <a asp-area="" asp-controller="Manage" asp-action="Index" title="Manage" class="nav-link js-scroll-trigger">My settings</a>
+                </li>
+                <li class="nav-item">
+                    <a asp-area="" asp-controller="Account" asp- asp-action="Logout" title="Manage" class="nav-link js-scroll-trigger">Log out</a>
+                </li>}
+    else
+    {
+        <li class="nav-item"><a asp-area="" asp-controller="Account" asp-action="Register" class="nav-link js-scroll-trigger">Register</a></li>
+        <li class="nav-item"><a asp-area="" asp-controller="Account" asp-action="Login" class="nav-link js-scroll-trigger">Log in</a></li>}
 
                 </ul>
             </div>
@@ -85,85 +86,6 @@
 
     @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(waiterState == NBXplorerState.Synching && lastStatus.BitcoinStatus != null)
-    {
-        <!-- 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.BitcoinStatus.Headers, Block height: @lastStatus.BitcoinStatus.Blocks)</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)lastStatus.BitcoinStatus.VerificationProgress)"
-                                 aria-valuemin="0" aria-valuemax="100" style="width:@((int)lastStatus.BitcoinStatus.VerificationProgress)%">
-                                @((int)lastStatus.BitcoinStatus.VerificationProgress)%
-                            </div>
-                        </div>
-                    </div>
-                    <div class="modal-footer">
-                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
-                    </div>
-                </div>
-
-            </div>
-        </div>
-    }
-    else if(waiterState == NBXplorerState.Synching && lastStatus.BitcoinStatus == null)
-    {
-        <!-- 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 starting...</h4>
-                        <button type="button" class="close" data-dismiss="modal">&times;</button>
-                    </div>
-                    <div class="modal-body">
-                        <p>Satoshi is rolling the blocks forward... Time to drink a cup of tea?</p>
-                    </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>
@@ -181,21 +103,10 @@
     <!-- Custom scripts for this template -->
     <script src="~/js/creative.js"></script>
 
-    @if(waiterState == NBXplorerState.NotConnected)
+
+    @if (!dashboard.IsFullySynched())
     {
-        <script type="text/javascript">
-            $(function () {
-                $("#no-nbxplorer").modal();
-            });
-        </script>
-    }
-    @if(waiterState == NBXplorerState.Synching)
-    {
-        <script type="text/javascript">
-            $(function () {
-                $("#synching-modal").modal();
-            });
-        </script>
+        @Html.Partial("SyncModal")
     }
 
     @RenderSection("Scripts", required: false)

BTCPayServer/Views/Stores/AddDerivationScheme.cshtml

@@ -0,0 +1,106 @@
+@model DerivationSchemeViewModel
+@{
+    Layout = "../Shared/_NavLayout.cshtml";
+    ViewData["Title"] = "Add derivation scheme";
+    ViewData.AddActivePage(BTCPayServer.Views.Stores.StoreNavPages.Index);
+}
+
+<h4>@ViewData["Title"]</h4>
+
+<div class="row">
+    <div class="col-md-6">
+        <div asp-validation-summary="All" class="text-danger"></div>
+    </div>
+</div>
+<div class="row">
+    <div class="col-md-6">
+        <form method="post">
+            <div class="form-group">
+                <h5>Derivation Scheme</h5>
+                @if(Model.AddressSamples.Count == 0)
+        {
+            <span>The DerivationScheme represents the destination of the funds received by your invoice. It is generated by your wallet software. Please, verify that you are generating the right addresses by clicking on 'Check ExtPubKey'</span>
+}
+            </div>
+            <div class="form-group">
+                <label asp-for="CryptoCurrency"></label>
+                <select asp-for="CryptoCurrency" asp-items="Model.CryptoCurrencies" class="form-control"></select>
+            </div>
+
+            <div class="form-group">
+                <input asp-for="DerivationScheme" class="form-control" />
+                <span asp-validation-for="DerivationScheme" class="text-danger"></span>
+            </div>
+            <div class="form-group">
+                <label asp-for="DerivationSchemeFormat"></label>
+                <select asp-for="DerivationSchemeFormat" asp-items="Model.DerivationSchemeFormats" class="form-control"></select>
+            </div>
+            <div class="form-group">
+                @if(Model.AddressSamples.Count == 0)
+        {
+            <span>BTCPay format memo</span>
+            <table class="table">
+                <thead class="thead-inverse">
+                    <tr>
+                        <th>Address type</th>
+                        <th>Example</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>P2WPKH</td>
+                        <td>xpub</td>
+                    </tr>
+                    <tr>
+                        <td>P2SH-P2WPKH</td>
+                        <td>xpub-[p2sh]</td>
+                    </tr>
+                    <tr>
+                        <td>P2PKH</td>
+                        <td>xpub-[legacy]</td>
+                    </tr>
+                    <tr>
+                        <td>Multi-sig P2WSH</td>
+                        <td>2-of-xpub1-xpub2</td>
+                    </tr>
+                    <tr>
+                        <td>Multi-sig P2SH-P2WSH</td>
+                        <td>2-of-xpub1-xpub2-[p2sh]</td>
+                    </tr>
+                    <tr>
+                        <td>Multi-sig P2SH</td>
+                        <td>2-of-xpub1-xpub2-[legacy]</td>
+                    </tr>
+                </tbody>
+            </table>
+}
+else
+{
+        <table class="table">
+            <thead class="thead-inverse">
+                <tr>
+                    <th>Key path</th>
+                    <th>Address</th>
+                </tr>
+            </thead>
+            <tbody>
+                @foreach(var sample in Model.AddressSamples)
+        {
+            <tr>
+                <td>@sample.KeyPath</td>
+                <td>@sample.Address</td>
+            </tr>
+}
+            </tbody>
+        </table>
+}
+            </div>
+            <button name="command" type="submit" class="btn btn-success" value="Save">Save</button>
+            <button name="command" type="submit" class="btn btn-default" value="Check">Check ExtPubKey</button>
+        </form>
+    </div>
+</div>
+
+@section Scripts {
+    @await Html.PartialAsync("_ValidationScriptsPartial")
+}

BTCPayServer/Views/Stores/ListStores.cshtml

@@ -27,7 +27,7 @@
                     <tr>
                         <th>Name</th>
                         <th>Website</th>
-                        <th>Balance</th>
+                        <th>Balances</th>
                         <th>Actions</th>
                     </tr>
                 </thead>
@@ -42,7 +42,16 @@
                                     <a href="@store.WebSite">@store.WebSite</a>
                                 }
                             </td>
-                            <td>@store.Balance</td>
+                            <td>
+                                @for(int i = 0; i < store.Balances.Length; i++)
+                                {
+                                    <span>@store.Balances[i]</span>
+                                    if(i != store.Balances.Length - 1)
+                                    {
+                                        <br />
+                                    }
+                                }
+                            </td>
                             <td><a asp-action="UpdateStore" asp-route-storeId="@store.Id">Settings</a> - <a asp-action="DeleteStore" asp-route-storeId="@store.Id">Remove</a></td>
                         </tr>
                     }

BTCPayServer/Views/Stores/UpdateStore.cshtml

@@ -25,20 +25,37 @@
                 <input asp-for="StoreName" class="form-control" />
                 <span asp-validation-for="StoreName" class="text-danger"></span>
             </div>
-            <div class="form-group">
-                <label asp-for="StoreName"></label>
-                <input asp-for="StoreName" class="form-control" />
-                <span asp-validation-for="StoreName" class="text-danger"></span>
-            </div>
             <div class="form-group">
                 <label asp-for="StoreWebsite"></label>
                 <input asp-for="StoreWebsite" class="form-control" />
                 <span asp-validation-for="StoreWebsite" class="text-danger"></span>
             </div>
+            <div class="form-group">
+                <label asp-for="DefaultCryptoCurrency"></label>
+                <select asp-for="DefaultCryptoCurrency" asp-items="Model.CryptoCurrencies" class="form-control"></select>
+            </div>
             <div class="form-group">
                 <label asp-for="NetworkFee"></label>
                 <input asp-for="NetworkFee" type="checkbox" class="form-check" />
             </div>
+            <div class="form-group">
+                <label asp-for="PreferredExchange"></label>
+                <input asp-for="PreferredExchange" class="form-control" />
+                <span asp-validation-for="PreferredExchange" class="text-danger"></span>
+                <p id="PreferredExchangeHelpBlock" class="form-text text-muted">
+                    Current price source is <a href="@Model.RateSource" target="_blank">@Model.PreferredExchange</a>.<small> (using 1 minute cache)</small>
+                </p>
+            </div>
+            <div class="form-group">
+                <label asp-for="RateMultiplier"></label>
+                <input asp-for="RateMultiplier" class="form-control" />
+                <span asp-validation-for="RateMultiplier" class="text-danger"></span>
+            </div>
+            <div class="form-group">
+                <label asp-for="InvoiceExpiration"></label>
+                <input asp-for="InvoiceExpiration" class="form-control" />
+                <span asp-validation-for="InvoiceExpiration" class="text-danger"></span>
+            </div>
             <div class="form-group">
                 <label asp-for="MonitoringExpiration"></label>
                 <input asp-for="MonitoringExpiration" class="form-control" />
@@ -55,81 +72,30 @@
             </div>
             <div class="form-group">
                 <h5>Derivation Scheme</h5>
-                @if(Model.AddressSamples.Count == 0)
-        {
-            <span>The DerivationScheme represents the destination of the funds received by your invoice. It is generated by your wallet software. Please, verify that you are generating the right addresses by clicking on 'Check ExtPubKey'</span>
-}
+                <span>The DerivationScheme represents the destination of the funds received by your invoice.</span>
             </div>
+
             <div class="form-group">
-                <input asp-for="DerivationScheme" class="form-control" />
-                <span asp-validation-for="DerivationScheme" class="text-danger"></span>
-            </div>
-            <div class="form-group">
-                <label asp-for="DerivationSchemeFormat"></label>
-                <select asp-for="DerivationSchemeFormat" asp-items="Model.DerivationSchemeFormats" class="form-control"></select>
-            </div>
-            <div class="form-group">
-                @if(Model.AddressSamples.Count == 0)
-        {
-                    <span>BTCPay format memo</span>
-            <table class="table">
-                <thead class="thead-inverse">
+                <a asp-action="AddDerivationScheme" class="btn btn-success" role="button"><span class="glyphicon glyphicon-plus"></span>Add or modify a derivation scheme</a>
+                <table class="table">
+                    <thead class="thead-inverse">
+                        <tr>
+                            <th>Crypto</th>
+                            <th>Derivation Scheme</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        @foreach(var scheme in Model.DerivationSchemes)
+                {
                     <tr>
-                        <th>Address type</th>
-                        <th>Example</th>
+                        <td>@scheme.Crypto</td>
+                        <td>@scheme.Value</td>
                     </tr>
-                </thead>
-                <tbody>
-                    <tr>
-                        <td>P2WPKH</td>
-                        <td>xpub</td>
-                    </tr>
-                    <tr>
-                        <td>P2SH-P2WPKH</td>
-                        <td>xpub-[p2sh]</td>
-                    </tr>
-                    <tr>
-                        <td>P2PKH</td>
-                        <td>xpub-[legacy]</td>
-                    </tr>
-                    <tr>
-                        <td>Multi-sig P2WSH</td>
-                        <td>2-of-xpub1-xpub2</td>
-                    </tr>
-                    <tr>
-                        <td>Multi-sig P2SH-P2WSH</td>
-                        <td>2-of-xpub1-xpub2-[p2sh]</td>
-                    </tr>
-                    <tr>
-                        <td>Multi-sig P2SH</td>
-                        <td>2-of-xpub1-xpub2-[legacy]</td>
-                    </tr>
-                </tbody>
-            </table>
-}
-else
-{
-        <table class="table">
-            <thead class="thead-inverse">
-                <tr>
-                    <th>Key path</th>
-                    <th>Address</th>
-                </tr>
-            </thead>
-            <tbody>
-                @foreach(var sample in Model.AddressSamples)
-        {
-            <tr>
-                <td>@sample.KeyPath</td>
-                <td>@sample.Address</td>
-            </tr>
-}
-            </tbody>
-        </table>
-}
+        }
+                    </tbody>
+                </table>
             </div>
             <button name="command" type="submit" class="btn btn-success" value="Save">Save</button>
-            <button name="command" type="submit" class="btn btn-default" value="Check">Check ExtPubKey</button>
         </form>
     </div>
 </div>

BTCPayServer/wwwroot/css/creative.css

@@ -43,7 +43,7 @@ h6 {
 }
 
 p {
-    font-size: 16px;
+    /*font-size: 16px;*/
     line-height: 1.5;
     margin-bottom: 20px;
 }

BTCPayServer/wwwroot/css/normalizer.css

@@ -8472,7 +8472,7 @@ strong {
 }
 
     .buyerTotalLine .fa-angle-double-down {
-        display: none;
+        opacity: 0.2;
         position: absolute;
         bottom: 0px;
         left: 49%;
@@ -8483,7 +8483,7 @@ strong {
     }
 
     .buyerTotalLine:hover .fa-angle-double-down {
-        display: block;
+        opacity: 1;
     }
 
     .buyerTotalLine .fa-angle-double-up {
@@ -8493,8 +8493,14 @@ strong {
         left: 49%;
     }
 
+    .buyerTotalLine.expanded .fa-angle-double-up {
+        display: block;
+        opacity: 0.2;
+    }
+
     .buyerTotalLine.expanded:hover .fa-angle-double-up {
         display: block;
+        opacity: 1;
     }
 
 .single-item-order__right__btc-price__chevron {

BTCPayServer/wwwroot/imlegacy/litecoin-symbol.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0.847 0.876 329.254 329.256"><title>Litecoin</title><path d="M330.102 165.503c0 90.922-73.705 164.629-164.626 164.629C74.554 330.132.848 256.425.848 165.503.848 74.582 74.554.876 165.476.876c90.92 0 164.626 73.706 164.626 164.627" fill="#bebebe"/><path d="M295.15 165.505c0 71.613-58.057 129.675-129.674 129.675-71.616 0-129.677-58.062-129.677-129.675 0-71.619 58.061-129.677 129.677-129.677 71.618 0 129.674 58.057 129.674 129.677" fill="#bebebe"/><path d="M155.854 209.482l10.693-40.264 25.316-9.249 6.297-23.663-.215-.587-24.92 9.104 17.955-67.608h-50.921l-23.481 88.23-19.605 7.162-6.478 24.395 19.59-7.156-13.839 51.998h135.521l8.688-32.362h-84.601" fill="#fff"/></svg>

BTCPayServer/wwwroot/js/core.js

@@ -14,6 +14,12 @@
 */
 
 // TODO: Vue controller... complete migrate to it for binding, animations can stay in jQuery
+Vue.config.ignoredElements = [
+    'line-items',
+    'low-fee-timeline',
+    // Ignoring custom HTML5 elements, eg: bp-spinner
+    /^bp-/
+];
 var checkoutCtrl = new Vue({
     el: '#checkoutCtrl',
     components: {
@@ -22,7 +28,7 @@ var checkoutCtrl = new Vue({
     data: {
         srvModel: srvModel
     }
-})
+});
 
 var display = $(".timer-row__time-left"); // Timer container
 
@@ -82,7 +88,7 @@ function emailForm() {
             $("#emailAddressForm").addClass("ng-touched ng-dirty ng-submitted ng-invalid");
 
         }
-    })
+    });
 }
 
 /* =============== Even listeners =============== */
@@ -130,7 +136,7 @@ $("#copy-tab").click(function () {
         $(".payment-tabs__slider").addClass("slide-right");
     }
 
-    if (!($("#copy").is(".active"))) {
+    if (!$("#copy").is(".active")) {
         $("#copy").show();
         $("#copy").addClass("active");
 
@@ -192,7 +198,7 @@ function onDataCallback(jsonData) {
 }
 
 function fetchStatus() {
-    var path = srvModel.serverUrl + "/i/" + srvModel.invoiceId + "/status";
+    var path = srvModel.serverUrl + "/i/" + srvModel.invoiceId + "/" + srvModel.cryptoCode + "/status";
     $.ajax({
         url: path,
         type: "GET"
@@ -215,7 +221,7 @@ if (supportsWebSockets) {
         };
     }
     catch (e) {
-        console.error("Error while connecting to websocket for invoice notifictions");
+        console.error("Error while connecting to websocket for invoice notifications");
     }
 }
 
@@ -278,7 +284,7 @@ function progressStart(timerMax) {
 
         var now = new Date();
         var timeDiff = end.getTime() - now.getTime();
-        var perc = 100 - Math.round((timeDiff / timerMax) * 100);
+        var perc = 100 - Math.round(timeDiff / timerMax * 100);
 
         if (perc === 75 && (status === "paidPartial" || status === "new")) {
             $(".timer-row").addClass("expiring-soon");