Fix api/rates allow to scope by cyrptoCode and storeId

Resolving problems with Vue console warnings

BTCPayServer.Tests/UnitTest1.cs

@@ -25,6 +25,7 @@ using Microsoft.Extensions.Caching.Memory;
 using BTCPayServer.Eclair;
 using System.Collections.Generic;
 using BTCPayServer.Models.StoreViewModels;
+using System.Threading.Tasks;
 
 namespace BTCPayServer.Tests
 {
@@ -50,7 +51,7 @@ namespace BTCPayServer.Tests
             // Some check that handling legacy stuff does not break things
             var cryptoData = entity.GetCryptoData("BTC", null, true);
             cryptoData.Calculate();
-            Assert.NotNull(cryptoData); 
+            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));
@@ -279,7 +280,8 @@ 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);
@@ -749,6 +751,10 @@ namespace BTCPayServer.Tests
             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)

BTCPayServer/BTCPayNetworkProvider.Bitcoin.cs

@@ -20,7 +20,7 @@ namespace BTCPayServer
             Add(new BTCPayNetwork()
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
-                BlockExplorerLink = "https://testnet.smartbit.com.au/tx/{0}",
+                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",

BTCPayServer/BTCPayNetworkProvider.Litecoin.cs

@@ -18,7 +18,7 @@ namespace BTCPayServer
             Add(new BTCPayNetwork()
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
-                BlockExplorerLink = "https://live.blockcypher.com/ltc/tx/{0}/",
+                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",

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.1.3</Version>
+		<Version>1.0.1.15</Version>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -48,6 +48,7 @@ namespace BTCPayServer.Controllers
                 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,
@@ -237,8 +238,7 @@ namespace BTCPayServer.Controllers
             try
             {
                 leases.Add(_EventAggregator.Subscribe<Events.InvoiceDataChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
-                leases.Add(_EventAggregator.Subscribe<Events.InvoicePaymentEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
-                leases.Add(_EventAggregator.Subscribe<Events.InvoiceStatusChangedEvent>(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));
@@ -414,6 +414,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

@@ -80,9 +80,9 @@ namespace BTCPayServer.Controllers
 
         internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl)
         {
-            var derivationStrategies = store.GetDerivationStrategies(_NetworkProvider).ToList();
+            var derivationStrategies = store.GetDerivationStrategies(_NetworkProvider).Where(c => _ExplorerClients.IsAvailable(c.Network.CryptoCode)).ToList();
             if (derivationStrategies.Count == 0)
-                throw new BitpayHttpException(400, "This store has not configured the derivation strategy");
+                throw new BitpayHttpException(400, "No derivation strategy are available now for this store");
             var entity = new InvoiceEntity
             {
                 InvoiceTime = DateTimeOffset.UtcNow
@@ -178,7 +178,7 @@ namespace BTCPayServer.Controllers
             entity.SetCryptoData(cryptoDatas);
             entity.PosData = invoice.PosData;
             entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, _NetworkProvider);
-            _EventAggregator.Publish(new Events.InvoiceCreatedEvent(entity.Id));
+            _EventAggregator.Publish(new Events.InvoiceEvent(entity, 1001, "invoice_created"));
             var resp = entity.EntityToDTO(_NetworkProvider);
             return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
         }

BTCPayServer/Controllers/RateController.cs

@@ -7,34 +7,66 @@ 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[]>
+            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(new DataWrapper<NBitpayClient.Rate[]>
                     (allRates.Select(r =>
                             new NBitpayClient.Rate()
                             {
                                 Code = r.Currency,
                                 Name = _CurrencyNameTable.GetCurrencyData(r.Currency)?.Name,
                                 Value = r.Value
-                            }).Where(n => n.Name != null).ToArray());
+                            }).Where(n => n.Name != null).ToArray()));
 
         }
+
+        [Route("api/rates")]
+        [HttpGet]
+        public Task<IActionResult> GetRates2(string cryptoCode = null, string storeId = null)
+        {
+            return GetRates(cryptoCode, storeId);
+        }
     }
 }

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
@@ -95,7 +96,7 @@ namespace BTCPayServer.Controllers
             var stores = await _Repo.GetStoresByUserId(GetUserId());
             var balances = stores
                                 .Select(s => s.GetDerivationStrategies(_NetworkProvider)
-                                              .Select(d => (Wallet: _WalletProvider.GetWallet(d.Network), 
+                                              .Select(d => (Wallet: _WalletProvider.GetWallet(d.Network),
                                                             DerivationStrategy: d.DerivationStrategyBase))
                                               .Where(_ => _.Wallet != null)
                                               .Select(async _ => (await _.Wallet.GetBalance(_.DerivationStrategy)).ToString() + " " + _.Wallet.Network.CryptoCode))
@@ -165,6 +166,7 @@ namespace BTCPayServer.Controllers
             vm.MonitoringExpiration = storeBlob.MonitoringExpiration;
             vm.InvoiceExpiration = storeBlob.InvoiceExpiration;
             vm.RateMultiplier = (double)storeBlob.GetRateMultiplier();
+            vm.PreferredExchange = storeBlob.PreferredExchange.IsCoinAverage() ? "coinaverage" : storeBlob.PreferredExchange;
             return View(vm);
         }
 
@@ -276,6 +278,8 @@ namespace BTCPayServer.Controllers
             {
                 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();
@@ -309,6 +313,10 @@ namespace BTCPayServer.Controllers
             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))
@@ -316,6 +324,19 @@ namespace BTCPayServer.Controllers
                 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);

BTCPayServer/Data/StoreData.cs

@@ -235,9 +235,29 @@ namespace BTCPayServer.Data
         }
 
         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/Events/InvoiceCreatedEvent.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Events
-{
-    public class InvoiceCreatedEvent
-    {
-        public InvoiceCreatedEvent(string id)
-        {
-            InvoiceId = id;
-        }
-
-        public string InvoiceId { get; set; }
-
-        public override string ToString()
-        {
-            return $"Invoice {InvoiceId} created";
-        }
-    }
-}

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

@@ -7,19 +7,29 @@ namespace BTCPayServer.Events
 {
     public class InvoiceIPNEvent
     {
-        public InvoiceIPNEvent(string invoiceId)
+        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 $"IPN sent for invoice {InvoiceId}";
-            return $"Error while sending IPN: {Error}";
+                return $"{ipnType} sent for invoice {InvoiceId}";
+            return $"Error while sending {ipnType}: {Error}";
         }
     }
 }

BTCPayServer/Events/InvoicePaymentEvent.cs

@@ -1,28 +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, string cryptoCode, string address)
-        {
-            InvoiceId = invoiceId;
-            Address = address;
-            CryptoCode = cryptoCode;
-        }
-
-        public string Address { get; set; }
-        public string CryptoCode { get; private set; }
-        public string InvoiceId { get; set; }
-
-        public override string ToString()
-        {
-            return $"{CryptoCode}: Invoice {InvoiceId} received a payment on {Address}";
-        }
-    }
-}

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/ExplorerClientProvider.cs

@@ -6,6 +6,7 @@ using System.Threading.Tasks;
 using BTCPayServer.Configuration;
 using BTCPayServer.Logging;
 using NBXplorer;
+using BTCPayServer.HostedServices;
 
 namespace BTCPayServer
 {
@@ -15,9 +16,10 @@ namespace BTCPayServer
         BTCPayServerOptions _Options;
 
         public BTCPayNetworkProvider NetworkProviders => _NetworkProviders;
-
-        public ExplorerClientProvider(BTCPayNetworkProvider networkProviders, BTCPayServerOptions options)
+        NBXplorerDashboard _Dashboard;
+        public ExplorerClientProvider(BTCPayNetworkProvider networkProviders, BTCPayServerOptions options, NBXplorerDashboard dashboard)
         {
+            _Dashboard = dashboard;
             _NetworkProviders = networkProviders;
             _Options = options;
 
@@ -68,6 +70,16 @@ namespace BTCPayServer
             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);

BTCPayServer/Extensions.cs

@@ -31,6 +31,12 @@ namespace BTCPayServer
             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();

BTCPayServer/HostedServices/InvoiceNotificationManager.cs

@@ -37,6 +37,9 @@ namespace BTCPayServer.HostedServices
             {
                 get; set;
             }
+
+            public int? EventCode { get; set; }
+            public string Message { get; set; }
         }
 
         public ILogger Logger
@@ -63,32 +66,32 @@ namespace BTCPayServer.HostedServices
             _NetworkProvider = networkProvider;
         }
 
-        async Task Notify(InvoiceEntity invoice)
+        async Task Notify(InvoiceEntity invoice, int? eventCode = null, string name = null)
         {
             CancellationTokenSource cts = new CancellationTokenSource(10000);
             try
             {
                 if (string.IsNullOrEmpty(invoice.NotificationURL))
                     return;
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id));
-                await SendNotification(invoice, cts.Token);
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name));
+                await SendNotification(invoice, eventCode, name, cts.Token);
                 return;
             }
-            catch(OperationCanceledException) when(cts.IsCancellationRequested)
+            catch (OperationCanceledException) when (cts.IsCancellationRequested)
             {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id)
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name)
                 {
                     Error = "Timeout"
                 });
             }
-            catch(Exception ex) // It fails, it is OK because we try with hangfire after
+            catch (Exception ex) // It fails, it is OK because we try with hangfire after
             {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id)
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name)
                 {
                     Error = ex.Message
                 });
             }
-            var invoiceStr = NBitcoin.JsonConverters.Serializer.ToString(new ScheduledJob() { TryCount = 0, Invoice = invoice });
+            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);
         }
@@ -107,14 +110,18 @@ namespace BTCPayServer.HostedServices
             CancellationTokenSource cts = new CancellationTokenSource(10000);
             try
             {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id));
-                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 (OperationCanceledException) when (cts.IsCancellationRequested)
             {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id)
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
                 {
                     Error = "Timeout"
                 });
@@ -123,12 +130,25 @@ namespace BTCPayServer.HostedServices
             }
             catch (Exception ex) // It fails, it is OK because we try with hangfire after
             {
-                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id)
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
                 {
                     Error = ex.Message
                 });
                 reschedule = true;
-                Logger.LogInformation("Job " + jobId + " threw exception " + ex.Message);
+
+                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); }
 
@@ -143,8 +163,23 @@ namespace BTCPayServer.HostedServices
             }
         }
 
+        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, CancellationToken cancellation)
+        private async Task<HttpResponseMessage> SendNotification(InvoiceEntity invoice, int? eventCode, string name, CancellationToken cancellation)
         {
             var request = new HttpRequestMessage();
             request.Method = HttpMethod.Post;
@@ -167,7 +202,7 @@ namespace BTCPayServer.HostedServices
             // 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;
@@ -177,8 +212,22 @@ namespace BTCPayServer.HostedServices
                 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), UTF8, "application/json");
+            request.Content = new StringContent(notificationString, UTF8, "application/json");
             var response = await _Client.SendAsync(request, cancellation);
             return response;
         }
@@ -193,42 +242,41 @@ namespace BTCPayServer.HostedServices
         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);
                 }
-                await SaveEvent(invoice.Id, e);
+
+                if (invoice.ExtendedNotifications)
+                {
+                    await Notify(invoice, e.EventCode, e.Name);
+                }
             }));
 
-            leases.Add(_EventAggregator.Subscribe<InvoiceCreatedEvent>(async e =>
+
+            leases.Add(_EventAggregator.Subscribe<InvoiceDataChangedEvent>(async e =>
             {
                 await SaveEvent(e.InvoiceId, e);
             }));
 
-            leases.Add(_EventAggregator.Subscribe<InvoiceDataChangedEvent>(async e => 
-            {
-                await SaveEvent(e.InvoiceId, e);
-            }));
-
-            leases.Add(_EventAggregator.Subscribe<InvoicePaymentEvent>(async e =>
-            {
-                await SaveEvent(e.InvoiceId, e);
-            }));
 
             leases.Add(_EventAggregator.Subscribe<InvoiceStopWatchedEvent>(async e =>
             {

BTCPayServer/HostedServices/InvoiceWatcher.cs

@@ -146,7 +146,7 @@ namespace BTCPayServer.HostedServices
                 context.MarkDirty();
                 await _InvoiceRepository.UnaffectAddress(invoice.Id);
 
-                context.Events.Add(new InvoiceStatusChangedEvent(invoice, "expired"));
+                context.Events.Add(new InvoiceEvent(invoice, 1004, "invoice_expired"));
                 invoice.Status = "expired";
             }
 
@@ -169,7 +169,7 @@ namespace BTCPayServer.HostedServices
                     invoice.Payments.Add(payment);
 #pragma warning restore CS0618
                     alreadyAccounted.Add(coin.Coin.Outpoint);
-                    context.Events.Add(new InvoicePaymentEvent(invoice.Id, coins.Wallet.Network.CryptoCode, coin.Coin.ScriptPubKey.GetDestinationAddress(coins.Wallet.Network.NBitcoinNetwork).ToString()));
+                    context.Events.Add(new InvoiceEvent(invoice, 1002, "invoice_receivedPayment"));
                     dirtyAddress = true;
                 }
                 if (dirtyAddress)
@@ -188,15 +188,16 @@ namespace BTCPayServer.HostedServices
                     {
                         if (invoice.Status == "new")
                         {
-                            context.Events.Add(new InvoiceStatusChangedEvent(invoice, "paid"));
+                            context.Events.Add(new InvoiceEvent(invoice, 1003, "invoice_paidInFull"));
                             invoice.Status = "paid";
                             invoice.ExceptionStatus = null;
                             await _InvoiceRepository.UnaffectAddress(invoice.Id);
                             context.MarkDirty();
                         }
-                        else if (invoice.Status == "expired")
+                        else if (invoice.Status == "expired" && invoice.ExceptionStatus != "paidLate")
                         {
                             invoice.ExceptionStatus = "paidLate";
+                            context.Events.Add(new InvoiceEvent(invoice, 1009, "invoice_paidAfterExpiration"));
                             context.MarkDirty();
                         }
                     }
@@ -246,14 +247,14 @@ namespace BTCPayServer.HostedServices
                        (totalConfirmed < accounting.TotalDue))
                     {
                         await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                        context.Events.Add(new InvoiceStatusChangedEvent(invoice, "invalid"));
+                        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 InvoiceStatusChangedEvent(invoice, "confirmed"));
+                        context.Events.Add(new InvoiceEvent(invoice, 1005, "invoice_confirmed"));
                         invoice.Status = "confirmed";
                         context.MarkDirty();
                     }
@@ -266,7 +267,7 @@ namespace BTCPayServer.HostedServices
                     var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
                     if (totalConfirmed >= accounting.TotalDue)
                     {
-                        context.Events.Add(new InvoiceStatusChangedEvent(invoice, "complete"));
+                        context.Events.Add(new InvoiceEvent(invoice, 1006, "invoice_completed"));
                         invoice.Status = "complete";
                         context.MarkDirty();
                     }
@@ -277,7 +278,7 @@ namespace BTCPayServer.HostedServices
         private IEnumerable<Task<NetworkCoins>> GetCoinsPerNetwork(UpdateInvoiceContext context, InvoiceEntity invoice, DerivationStrategy[] strategies)
         {
             return strategies
-                                .Select(d => (Wallet: _WalletProvider.GetWallet(d.Network),
+                                .Select(d => (Wallet: _WalletProvider.IsAvailable(d.Network) ? _WalletProvider.GetWallet(d.Network) : null,
                                               Network: d.Network,
                                               Strategy: d.DerivationStrategyBase))
                                 .Where(d => d.Wallet != null)
@@ -442,7 +443,13 @@ namespace BTCPayServer.HostedServices
 
             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.InvoiceCreatedEvent>(async b => { await Watch(b.InvoiceId); }));
+            leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async b =>
+            {
+                if (b.Name == "invoice_created")
+                {
+                    await Watch(b.InvoiceId);
+                }
+            }));
 
             return Task.CompletedTask;
         }
@@ -481,19 +488,25 @@ namespace BTCPayServer.HostedServices
             {
                 foreach (var item in _WatchRequests.GetConsumingEnumerable(cancellation))
                 {
+                    bool added = false;
                     var task = executing.GetOrAdd(item, async i =>
                     {
                         try
                         {
+                            added = true;
                             await UpdateInvoice(i, cancellation);
                         }
                         catch (Exception ex) when (!cancellation.IsCancellationRequested)
                         {
-                            Logs.PayServer.LogCritical(ex, $"Error in the InvoiceWatcher loop (Invoice {item})");
-                            await Task.Delay(2000, cancellation);
+                            Logs.PayServer.LogCritical(ex, $"Error in the InvoiceWatcher loop (Invoice {i})");
                         }
-                        finally { executing.TryRemove(item, out Task useless); }
                     });
+
+                    if (!added && task.Status == TaskStatus.RanToCompletion)
+                    {
+                        executing.TryRemove(item, out Task t);
+                        _WatchRequests.Add(item);
+                    }
                 }
             }
             catch when (cancellation.IsCancellationRequested)

BTCPayServer/HostedServices/NBXplorerListener.cs

@@ -87,19 +87,22 @@ namespace BTCPayServer.HostedServices
             }, null, 0, (int)PollInterval.TotalMilliseconds);
             leases.Add(_ListenPoller);
 
-            leases.Add(_Aggregator.Subscribe<Events.InvoiceCreatedEvent>(async inv =>
+            leases.Add(_Aggregator.Subscribe<Events.InvoiceEvent>(async inv =>
             {
-                var invoice = await _InvoiceRepository.GetInvoice(null, inv.InvoiceId);
-                List<Task> listeningDerivations = new List<Task>();
-                foreach (var notificationSessions in _Sessions)
+                if (inv.Name == "invoice_created")
                 {
-                    var derivationStrategy = GetStrategy(notificationSessions.Key, invoice);
-                    if (derivationStrategy != null)
+                    var invoice = await _InvoiceRepository.GetInvoice(null, inv.InvoiceId);
+                    List<Task> listeningDerivations = new List<Task>();
+                    foreach (var notificationSessions in _Sessions)
                     {
-                        listeningDerivations.Add(notificationSessions.Value.ListenDerivationSchemesAsync(new[] { derivationStrategy }, _Cts.Token));
+                        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);
                 }
-                await Task.WhenAll(listeningDerivations.ToArray()).ConfigureAwait(false);
             }));
             return Task.CompletedTask;
         }

BTCPayServer/HostedServices/NBXplorerWaiter.cs

@@ -41,6 +41,11 @@ namespace BTCPayServer.HostedServices
             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;

BTCPayServer/Models/InvoicingModels/InvoiceDetailsModel.cs

@@ -97,6 +97,8 @@ namespace BTCPayServer.Models.InvoicingModels
             get;
             set;
         }
+
+        public string TransactionSpeed { get; set; }
         public object StoreName
         {
             get;

BTCPayServer/Models/StoreViewModels/StoreViewModel.cs

@@ -47,6 +47,17 @@ namespace BTCPayServer.Models.StoreViewModels
 
         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
+            {
+                return PreferredExchange.IsCoinAverage() ? "https://apiv2.bitcoinaverage.com/indices/global/ticker/short" : $"https://apiv2.bitcoinaverage.com/exchanges/{PreferredExchange}";
+            }
+        }
+
         [Display(Name = "Multiply the original rate by ...")]
         [Range(0.01, 10.0)]
         public double RateMultiplier

BTCPayServer/Program.cs

@@ -45,6 +45,7 @@ namespace BTCPayServer
                     .ConfigureLogging(l =>
                     {
                         l.AddFilter("Microsoft", LogLevel.Error);
+                        l.AddFilter("Microsoft.AspNetCore.Antiforgery.Internal", LogLevel.Critical);
                         l.AddProvider(new CustomConsoleLogProvider(processor));
                     })
                     .UseStartup<Startup>()

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
 {
@@ -43,6 +45,7 @@ namespace BTCPayServer.Services.Invoices
 
         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 });

BTCPayServer/Services/Rates/CachedDefaultRateProviderFactory.cs

@@ -11,6 +11,15 @@ namespace BTCPayServer.Services.Rates
     {
         IMemoryCache _Cache;
         ConcurrentDictionary<string, IRateProvider> _Providers = new ConcurrentDictionary<string, IRateProvider>();
+
+        public IMemoryCache Cache
+        {
+            get
+            {
+                return _Cache;
+            }
+        }
+
         public CachedDefaultRateProviderFactory(IMemoryCache cache)
         {
             if (cache == null)
@@ -18,10 +27,12 @@ namespace BTCPayServer.Services.Rates
             _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, network.DefaultRateProvider, _Cache) { CacheSpan = CacheSpan });
+            return _Providers.GetOrAdd(network.CryptoCode, new CachedRateProvider(network.CryptoCode, RateProvider ?? network.DefaultRateProvider, _Cache) { CacheSpan = CacheSpan });
         }
     }
 }

BTCPayServer/Services/Rates/CachedRateProvider.cs

@@ -19,19 +19,28 @@ namespace BTCPayServer.Services.Rates
             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
         {
             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 + "_" + _CryptoCode, (ICacheEntry entry) =>
+            return MemoryCache.GetOrCreateAsync("CURR_" + currency + "_" + _CryptoCode + "_" + AdditionalScope, (ICacheEntry entry) =>
             {
                 entry.AbsoluteExpiration = DateTimeOffset.UtcNow + CacheSpan;
                 return _Inner.GetRateAsync(currency);
@@ -40,11 +49,13 @@ namespace BTCPayServer.Services.Rates
         
         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

@@ -24,6 +24,8 @@ namespace BTCPayServer.Services.Rates
             CryptoCode = cryptoCode ?? "BTC";
         }
 
+        public string Exchange { get; set; }
+
         public string CryptoCode { get; set; }
 
         public string Market
@@ -45,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)
             {
 
@@ -57,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(CryptoCode, StringComparison.OrdinalIgnoreCase))
-                              .ToDictionary(p => p.Name.Substring(CryptoCode.Length, p.Name.Length - CryptoCode.Length), p => ToDecimal(p.Value["last"]));
+                              .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/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/Wallets/BTCPayWalletProvider.cs

@@ -38,5 +38,10 @@ namespace BTCPayServer.Services.Wallets
                 return null;
             return new BTCPayWallet(client, _TransactionCacheProvider.GetTransactionCache(network), network);
         }
+
+        public bool IsAvailable(BTCPayNetwork network)
+        {
+            return _Client.IsAvailable(network);
+        }
     }
 }

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>

BTCPayServer/Views/Invoice/Invoice.cshtml

@@ -53,6 +53,10 @@
                         <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>

BTCPayServer/Views/Stores/UpdateStore.cshtml

@@ -38,6 +38,14 @@
                 <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" />

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/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: {