Can delete user

Allowing user to invalidate paid invoice

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -108,7 +108,6 @@ namespace BTCPayServer.Tests
             _Host.Start();
             Runtime = (BTCPayServerRuntime)_Host.Services.GetService(typeof(BTCPayServerRuntime));
             var watcher = (InvoiceWatcher)_Host.Services.GetService(typeof(InvoiceWatcher));
-            watcher.PollInterval = TimeSpan.FromMilliseconds(500);
         }
 
         public BTCPayServerRuntime Runtime

BTCPayServer.Tests/Logging/Logs.cs

@@ -71,7 +71,7 @@ namespace BTCPayServer.Tests.Logging
         public void LogInformation(string msg)
         {
             if (msg != null)
-                _Helper.WriteLine(Name + ":   " + msg);
+                _Helper.WriteLine(DateTimeOffset.UtcNow + " :" + Name + ":   " + msg);
         }
     }
     public class Logs

BTCPayServer.Tests/TestAccount.cs

@@ -10,6 +10,7 @@ using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
+using NBXplorer.DerivationStrategy;
 
 namespace BTCPayServer.Tests
 {
@@ -55,14 +56,17 @@ namespace BTCPayServer.Tests
             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 = ExtKey.Neuter().ToString() + "-[legacy]",
+                DerivationScheme = DerivationScheme.ToString(),
                 SpeedPolicy = SpeedPolicy.MediumSpeed
             }, "Save");
             return store;
         }
 
+        public DerivationStrategyBase DerivationScheme { get; set; }
+
         private async Task RegisterAsync()
         {
             var account = parent.PayTester.GetController<AccountController>();

BTCPayServer.Tests/UnitTest1.cs

@@ -45,22 +45,22 @@ namespace BTCPayServer.Tests
             Assert.Equal(Money.Coins(1.1m), entity.GetCryptoDue());
             Assert.Equal(Money.Coins(1.1m), entity.GetTotalCryptoDue());
 
-            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.5m), new Key()) });
+            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.5m), new Key()), Accounted = true });
 
             //Since we need to spend one more txout, it should be 1.1 - 0,5 + 0.1
             Assert.Equal(Money.Coins(0.7m), entity.GetCryptoDue());
             Assert.Equal(Money.Coins(1.2m), entity.GetTotalCryptoDue());
 
-            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()) });
+            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()), Accounted = true });
             Assert.Equal(Money.Coins(0.6m), entity.GetCryptoDue());
             Assert.Equal(Money.Coins(1.3m), entity.GetTotalCryptoDue());
 
-            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.6m), new Key()) });
+            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.6m), new Key()), Accounted = true });
 
             Assert.Equal(Money.Zero, entity.GetCryptoDue());
             Assert.Equal(Money.Coins(1.3m), entity.GetTotalCryptoDue());
 
-            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()) });
+            entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()), Accounted = true });
 
             Assert.Equal(Money.Zero, entity.GetCryptoDue());
             Assert.Equal(Money.Coins(1.3m), entity.GetTotalCryptoDue());
@@ -194,6 +194,74 @@ namespace BTCPayServer.Tests
             }
         }
 
+        [Fact]
+        public void CanRBFPayment()
+        {
+            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"
+                }, Facade.Merchant);
+
+                var payment1 = Money.Coins(0.04m);
+                var payment2 = Money.Coins(0.08m);
+                var tx1 = new uint256(tester.ExplorerNode.SendCommand("sendtoaddress", new object[]
+                {
+                    invoice.BitcoinAddress.ToString(),
+                    payment1.ToString(),
+                    null, //comment
+                    null, //comment_to
+                    false, //subtractfeefromamount
+                    true, //replaceable
+                }).ResultString);
+                var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, tester.Network);
+
+                Eventually(() =>
+                {
+                    tester.SimulateCallback(invoiceAddress);
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal(payment1, invoice.BtcPaid);
+                    invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, tester.Network);
+                });
+
+                var tx = tester.ExplorerNode.GetRawTransaction(new uint256(tx1));
+                foreach (var input in tx.Inputs)
+                {
+                    input.ScriptSig = Script.Empty; //Strip signatures
+                }
+                var change = tx.Outputs.First(o => o.Value != payment1);
+                var output = tx.Outputs.First(o => o.Value == payment1);
+                output.Value = payment2;
+                output.ScriptPubKey = invoiceAddress.ScriptPubKey;
+                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);
+                Eventually(() =>
+                {
+                    tester.SimulateCallback(invoiceAddress);
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal(payment2, invoice.BtcPaid);
+                });
+            }
+        }
+
+        [Fact]
+        public void CanParseFilter()
+        {
+            var filter = "storeid:abc status:abed blabhbalh ";
+            var search = new SearchString(filter);
+            Assert.Equal("storeid:abc status:abed blabhbalh", search.ToString());
+            Assert.Equal("blabhbalh", search.TextSearch);
+            Assert.Equal("abc", search.Filters["storeid"]);
+            Assert.Equal("abed", search.Filters["status"]);
+        }
+
         [Fact]
         public void InvoiceFlowThroughDifferentStatesCorrectly()
         {
@@ -217,19 +285,23 @@ namespace BTCPayServer.Tests
                 }, Facade.Merchant);
                 var repo = tester.PayTester.GetService<InvoiceRepository>();
                 var ctx = tester.PayTester.GetService<ApplicationDbContextFactory>().CreateContext();
-                var textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
-                {
-                    StoreId = user.StoreId,
-                    TextSearch = invoice.OrderId
-                }).GetAwaiter().GetResult();
-                Assert.Equal(1, textSearchResult.Length);
-                textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
-                {
-                    StoreId = user.StoreId,
-                    TextSearch = invoice.Id
-                }).GetAwaiter().GetResult();
 
-                Assert.Equal(1, textSearchResult.Length);
+                Eventually(() =>
+                {
+                    var textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
+                    {
+                        StoreId = user.StoreId,
+                        TextSearch = invoice.OrderId
+                    }).GetAwaiter().GetResult();
+                    Assert.Equal(1, textSearchResult.Length);
+                    textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
+                    {
+                        StoreId = user.StoreId,
+                        TextSearch = invoice.Id
+                    }).GetAwaiter().GetResult();
+
+                    Assert.Equal(1, textSearchResult.Length);
+                });
 
                 invoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                 Assert.Equal(Money.Coins(0), invoice.BtcPaid);

BTCPayServer.Tests/docker-compose.yml

@@ -21,7 +21,7 @@ services:
       - "tests:127.0.0.1"
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.0.25
+    image: nicolasdorier/nbxplorer:1.0.0.29
     ports:
       - "32838:32838"
     expose: 
@@ -33,11 +33,15 @@ services:
       NBXPLORER_RPCPASSWORD: DwubwWsoo3
       NBXPLORER_NODEENDPOINT: bitcoind:39388
       NBXPLORER_BIND: 0.0.0.0:32838
+      NBXPLORER_VERBOSE: 1
       NBXPLORER_NOAUTH: 1
     links:
       - bitcoind
       - postgres
 
+  eclair:
+    image: nicolasdorier/docker-bitcoin:0.15.0.1
+
   bitcoind:
     container_name: btcpayserver_dev_bitcoind
     image: nicolasdorier/docker-bitcoin:0.15.0.1
@@ -45,7 +49,13 @@ services:
       - "43782:43782"
       - "39388:39388"
     environment:
-      BITCOIN_EXTRA_ARGS: "rpcuser=ceiwHEbqWI83\nrpcpassword=DwubwWsoo3\nregtest=1\nrpcport=43782\nport=39388\nwhitelist=0.0.0.0/0"
+      BITCOIN_EXTRA_ARGS: |
+        rpcuser=ceiwHEbqWI83
+        rpcpassword=DwubwWsoo3
+        regtest=1
+        rpcport=43782
+        port=39388
+        whitelist=0.0.0.0/0
     expose:
       - "43782"
       - "39388"

BTCPayServer/Authentication/TokenRepository.cs

@@ -69,7 +69,7 @@ namespace BTCPayServer.Authentication
             {
                 var now = DateTime.UtcNow;
                 var expiration = DateTime.UtcNow + TimeSpan.FromMinutes(15);
-                await ctx.PairingCodes.AddAsync(new PairingCodeData()
+                ctx.PairingCodes.Add(new PairingCodeData()
                 {
                     Id = pairingCodeId,
                     DateCreated = now,

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.0.27</Version>
+		<Version>1.0.0.37</Version>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />
@@ -21,8 +21,8 @@
     <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.1" />
     <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.41" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.12" />	  
+    <PackageReference Include="NBitcoin" Version="4.0.0.48" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.13" />	  
     <PackageReference Include="DBreeze" Version="1.87.0" />
     <PackageReference Include="NBXplorer.Client" Version="1.0.0.18" />
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.1" />

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -57,6 +57,7 @@ namespace BTCPayServer.Configuration
             CookieFile = conf.GetOrDefault<string>("explorer.cookiefile", networkInfo.DefaultExplorerCookieFile);
             RequireHttps = conf.GetOrDefault<bool>("requirehttps", false);
             PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
+            ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
         }
 
         public bool RequireHttps
@@ -68,5 +69,10 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
+        public Uri ExternalUrl
+        {
+            get;
+            set;
+        }
     }
 }

BTCPayServer/Configuration/BTCPayServerRuntime.cs

@@ -49,11 +49,6 @@ namespace BTCPayServer.Configuration
             {
                 throw new ConfigException($"Could not connect to NBXplorer, {ex.Message}");
             }
-            DBreezeEngine db = new DBreezeEngine(CreateDBPath(opts, "TokensDB"));
-            _Resources.Add(db);
-
-            db = new DBreezeEngine(CreateDBPath(opts, "InvoiceDB"));
-            _Resources.Add(db);
 
             ApplicationDbContextFactory dbContext = null;
             if (opts.PostgresConnectionString == null)
@@ -68,7 +63,9 @@ namespace BTCPayServer.Configuration
                 dbContext = new ApplicationDbContextFactory(DatabaseType.Postgres, opts.PostgresConnectionString);
             }
             DBFactory = dbContext;
-            InvoiceRepository = new InvoiceRepository(dbContext, db, Network);
+
+            InvoiceRepository = new InvoiceRepository(dbContext, CreateDBPath(opts, "InvoiceDB"), Network);
+            _Resources.Add(InvoiceRepository);
         }
 
         private static string CreateDBPath(BTCPayServerOptions opts, string name)

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -19,8 +19,8 @@ namespace BTCPayServer.Configuration
         {
             CommandLineApplication app = new CommandLineApplication(true)
             {
-                FullName = "NBXplorer\r\nLightweight block explorer for tracking HD wallets",
-                Name = "NBXplorer"
+                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);
@@ -30,7 +30,7 @@ namespace BTCPayServer.Configuration
             app.Option("--postgres", $"Connection string to postgres database (default: sqlite is used)", CommandOptionType.SingleValue);
             app.Option("--explorerurl", $"Url of the NBxplorer (default: : Default setting of NBXplorer for the network)", CommandOptionType.SingleValue);
             app.Option("--explorercookiefile", $"Path to the cookie file (default: Default setting of NBXplorer for the network)", CommandOptionType.SingleValue);
-
+            app.Option("--externalurl", $"The expected external url of this service, use if BTCPay is behind a reverse proxy (default: empty, use the incoming HTTP request to figure out)", CommandOptionType.SingleValue);
             return app;
         }
 

BTCPayServer/Controllers/AccountController.cs

@@ -235,8 +235,11 @@ namespace BTCPayServer.Controllers
 
         [HttpGet]
         [AllowAnonymous]
-        public IActionResult Register(string returnUrl = null)
+        public async Task<IActionResult> Register(string returnUrl = null)
         {
+            var policies = await _SettingsRepository.GetSettingAsync<PoliciesSettings>() ?? new PoliciesSettings();
+            if (policies.LockSubscription)
+                return RedirectToAction(nameof(HomeController.Index), "Home");
             ViewData["ReturnUrl"] = returnUrl;
             return View();
         }
@@ -247,9 +250,11 @@ namespace BTCPayServer.Controllers
         public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null)
         {
             ViewData["ReturnUrl"] = returnUrl;
+            var policies = await _SettingsRepository.GetSettingAsync<PoliciesSettings>() ?? new PoliciesSettings();
+            if (policies.LockSubscription)
+                return RedirectToAction(nameof(HomeController.Index), "Home");
             if (ModelState.IsValid)
             {
-                var policies = await _SettingsRepository.GetSettingAsync<PoliciesSettings>() ?? new PoliciesSettings();
                 var user = new ApplicationUser { UserName = model.Email, Email = model.Email, RequiresEmailConfirmation = policies.RequiresConfirmedEmail };
                 var result = await _userManager.CreateAsync(user, model.Password);
                 if (result.Succeeded)

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -15,6 +15,7 @@ using System.Linq;
 using System.Security.Claims;
 using System.Text;
 using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
 
 namespace BTCPayServer.Controllers
 {
@@ -23,11 +24,11 @@ namespace BTCPayServer.Controllers
 
         [HttpPost]
         [Route("invoices/{invoiceId}")]
-        public async Task<IActionResult> Invoice(string invoiceId, string command)
+        public IActionResult Invoice(string invoiceId, string command)
         {
             if (command == "refresh")
             {
-                await _Watcher.WatchAsync(invoiceId, true);
+                _Watcher.Watch(invoiceId);
             }
             StatusMessage = "Invoice is state is being refreshed, please refresh the page soon...";
             return RedirectToAction(nameof(Invoice), new
@@ -118,8 +119,7 @@ namespace BTCPayServer.Controllers
                 return null;
             var store = await _StoreRepository.FindStore(invoice.StoreId);
             var dto = invoice.EntityToDTO();
-
-            var cryptoFormat = _CurrencyNameTable.GetCurrencyProvider("BTC");
+            var currency = invoice.ProductInformation.Currency;
             var model = new PaymentModel()
             {
                 ServerUrl = HttpContext.Request.GetAbsoluteRoot(),
@@ -133,7 +133,7 @@ namespace BTCPayServer.Controllers
                 ExpirationSeconds = Math.Max(0, (int)(invoice.ExpirationTime - DateTimeOffset.UtcNow).TotalSeconds),
                 MaxTimeSeconds = (int)(invoice.ExpirationTime - invoice.InvoiceTime).TotalSeconds,
                 ItemDesc = invoice.ProductInformation.ItemDesc,
-                Rate = invoice.Rate.ToString("C", _CurrencyNameTable.GetCurrencyProvider(invoice.ProductInformation.Currency)),
+                Rate = invoice.Rate.ToString("C", _CurrencyNameTable.GetCurrencyProvider(currency)) + $" ({currency})",
                 MerchantRefLink = invoice.RedirectURL ?? "/",
                 StoreName = store.StoreName,
                 TxFees = invoice.TxFee.ToString(),
@@ -188,12 +188,15 @@ namespace BTCPayServer.Controllers
         public async Task<IActionResult> ListInvoices(string searchTerm = null, int skip = 0, int count = 20)
         {
             var model = new InvoicesModel();
+            var filterString = new SearchString(searchTerm);
             foreach (var invoice in await _InvoiceRepository.GetInvoices(new InvoiceQuery()
             {
-                TextSearch = searchTerm,
+                TextSearch = filterString.TextSearch,
                 Count = count,
                 Skip = skip,
-                UserId = GetUserId()
+                UserId = GetUserId(),
+                Status = filterString.Filters.TryGet("status"),
+                StoreId = filterString.Filters.TryGet("storeid")
             }))
             {
                 model.SearchTerm = searchTerm;
@@ -246,21 +249,30 @@ namespace BTCPayServer.Controllers
                     storeId = store.Id
                 });
             }
-            var result = await CreateInvoiceCore(new Invoice()
-            {
-                Price = model.Amount.Value,
-                Currency = "USD",
-                PosData = model.PosData,
-                OrderId = model.OrderId,
-                //RedirectURL = redirect + "redirect",
-                NotificationURL = model.NotificationUrl,
-                ItemDesc = model.ItemDesc,
-                FullNotifications = true,
-                BuyerEmail = model.BuyerEmail,
-            }, store, HttpContext.Request.GetAbsoluteRoot());
 
-            StatusMessage = $"Invoice {result.Data.Id} just created!";
-            return RedirectToAction(nameof(ListInvoices));
+            try
+            {
+                var result = await CreateInvoiceCore(new Invoice()
+                {
+                    Price = model.Amount.Value,
+                    Currency = model.Currency,
+                    PosData = model.PosData,
+                    OrderId = model.OrderId,
+                    //RedirectURL = redirect + "redirect",
+                    NotificationURL = model.NotificationUrl,
+                    ItemDesc = model.ItemDesc,
+                    FullNotifications = true,
+                    BuyerEmail = model.BuyerEmail,
+                }, store, HttpContext.Request.GetAbsoluteRoot());
+
+                StatusMessage = $"Invoice {result.Data.Id} just created!";
+                return RedirectToAction(nameof(ListInvoices));
+            }
+            catch (RateUnavailableException)
+            {
+                ModelState.TryAddModelError(nameof(model.Currency), "Unsupported currency");
+                return View(model);
+            }
         }
 
         private async Task<SelectList> GetStores(string userId, string storeId = null)
@@ -281,6 +293,16 @@ namespace BTCPayServer.Controllers
             });
         }
 
+        [HttpPost]
+        [Route("invoices/invalidatepaid")]
+        [Authorize(AuthenticationSchemes = "Identity.Application")]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> InvalidatePaidInvoice(string invoiceId)
+        {
+            await _InvoiceRepository.UpdatePaidInvoiceToInvalid(invoiceId);
+            return RedirectToAction(nameof(ListInvoices));
+        }
+
         [TempData]
         public string StatusMessage
         {

BTCPayServer/Controllers/InvoiceController.cs

@@ -78,7 +78,7 @@ namespace BTCPayServer.Controllers
             _FeeProvider = feeProvider ?? throw new ArgumentNullException(nameof(feeProvider));
         }
 
-        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl, double expiryMinutes = 15, double monitoringMinutes = 60)
+        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl, double expiryMinutes = 15)
         {
             //TODO: expiryMinutes (time before a new invoice can become paid) and monitoringMinutes (time before a paid invoice becomes invalid)  should be configurable at store level
             var derivationStrategy = store.DerivationStrategy;
@@ -87,12 +87,13 @@ namespace BTCPayServer.Controllers
                 InvoiceTime = DateTimeOffset.UtcNow,
                 DerivationStrategy = derivationStrategy ?? throw new BitpayHttpException(400, "This store has not configured the derivation strategy")
             };
+            var storeBlob = store.GetStoreBlob(_Network);
             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.MonitoringExpiration = entity.InvoiceTime.AddMinutes(monitoringMinutes);
+            entity.MonitoringExpiration = entity.ExpirationTime + TimeSpan.FromMinutes(storeBlob.MonitoringExpiration);
             entity.OrderId = invoice.OrderId;
             entity.ServerUrl = serverUrl;
             entity.FullNotifications = invoice.FullNotifications;
@@ -110,13 +111,16 @@ namespace BTCPayServer.Controllers
             entity.RedirectURL = invoice.RedirectURL ?? store.StoreWebsite;
             entity.Status = "new";
             entity.SpeedPolicy = ParseSpeedPolicy(invoice.TransactionSpeed, store.SpeedPolicy);
-            entity.TxFee = store.GetStoreBlob(_Network).NetworkFeeDisabled ? Money.Zero : (await _FeeProvider.GetFeeRateAsync()).GetFee(100); // assume price for 100 bytes
-            entity.Rate = (double)await _RateProvider.GetRateAsync(invoice.Currency);
-            entity.PosData = invoice.PosData;
-            entity.DepositAddress = await _Wallet.ReserveAddressAsync(ParseDerivationStrategy(derivationStrategy));
 
+            var getFeeRate = _FeeProvider.GetFeeRateAsync();
+            var getRate = _RateProvider.GetRateAsync(invoice.Currency);
+            var getAddress = _Wallet.ReserveAddressAsync(ParseDerivationStrategy(derivationStrategy));
+            entity.TxFee = storeBlob.NetworkFeeDisabled ? Money.Zero : (await getFeeRate).GetFee(100); // assume price for 100 bytes
+            entity.Rate = (double)await getRate;
+            entity.PosData = invoice.PosData;
+            entity.DepositAddress = await getAddress;
             entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity);
-            await _Watcher.WatchAsync(entity.Id);
+            _Watcher.Watch(entity.Id);
             var resp = entity.EntityToDTO();
             return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
         }

BTCPayServer/Controllers/ServerController.cs

@@ -32,15 +32,50 @@ namespace BTCPayServer.Controllers
         public IActionResult ListUsers()
         {
             var users = new UsersViewModel();
+            users.StatusMessage = StatusMessage;
             users.Users
                 = _UserManager.Users.Select(u => new UsersViewModel.UserViewModel()
                 {
                     Name = u.UserName,
-                    Email = u.Email
+                    Email = u.Email,
+                    Id = u.Id
                 }).ToList();
             return View(users);
         }
 
+
+        [Route("server/users/{userId}/delete")]
+        public async Task<IActionResult> DeleteUser(string userId)
+        {
+            var user = userId == null ? null : await _UserManager.FindByIdAsync(userId);
+            if (user == null)
+                return NotFound();
+            return View("Confirm", new ConfirmModel()
+            {
+                Title = "Delete user " + user.Email,
+                Description = "This user will be permanently deleted",
+                Action = "Delete"
+            });
+        }
+
+        [Route("server/users/{userId}/delete")]
+        [HttpPost]
+        public async Task<IActionResult> DeleteUserPost(string userId)
+        {
+            var user = userId == null ? null : await _UserManager.FindByIdAsync(userId);
+            if (user == null)
+                return NotFound();
+            await _UserManager.DeleteAsync(user);
+            StatusMessage = "User deleted";
+            return RedirectToAction(nameof(ListUsers));
+        }
+
+        [TempData]
+        public string StatusMessage
+        {
+            get; set;
+        }
+
         [Route("server/emails")]
         public async Task<IActionResult> Emails()
         {

BTCPayServer/Controllers/StoresController.cs

@@ -144,13 +144,16 @@ namespace BTCPayServer.Controllers
             if (store == null)
                 return NotFound();
 
+            var storeBlob = store.GetStoreBlob(_Network);
             var vm = new StoreViewModel();
+            vm.Id = store.Id;
             vm.StoreName = store.StoreName;
             vm.StoreWebsite = store.StoreWebsite;
-            vm.NetworkFee = !store.GetStoreBlob(_Network).NetworkFeeDisabled;
+            vm.NetworkFee = !storeBlob.NetworkFeeDisabled;
             vm.SpeedPolicy = store.SpeedPolicy;
             vm.DerivationScheme = store.DerivationStrategy;
             vm.StatusMessage = StatusMessage;
+            vm.MonitoringExpiration = storeBlob.MonitoringExpiration;
             return View(vm);
         }
 
@@ -205,11 +208,12 @@ namespace BTCPayServer.Controllers
                     }
                 }
 
-                if (store.GetStoreBlob(_Network).NetworkFeeDisabled != !model.NetworkFee)
+                var blob = store.GetStoreBlob(_Network);
+                blob.NetworkFeeDisabled = !model.NetworkFee;
+                blob.MonitoringExpiration = model.MonitoringExpiration;
+
+                if (store.SetStoreBlob(blob, _Network))
                 {
-                    var blob = store.GetStoreBlob(_Network);
-                    blob.NetworkFeeDisabled = !model.NetworkFee;
-                    store.SetStoreBlob(blob, _Network);
                     needUpdate = true;
                 }
 

BTCPayServer/CustomThreadPool.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BTCPayServer
+{
+    class CustomThreadPool : IDisposable
+    {
+        CancellationTokenSource _Cancel = new CancellationTokenSource();
+        TaskCompletionSource<bool> _Exited;
+        int _ExitedCount = 0;
+        Thread[] _Threads;
+        Exception _UnhandledException;
+        BlockingCollection<(Action, TaskCompletionSource<object>)> _Actions = new BlockingCollection<(Action, TaskCompletionSource<object>)>(new ConcurrentQueue<(Action, TaskCompletionSource<object>)>());
+
+        public CustomThreadPool(int threadCount, string threadName)
+        {
+            if (threadCount <= 0)
+                throw new ArgumentOutOfRangeException(nameof(threadCount));
+            _Exited = new TaskCompletionSource<bool>();
+            _Threads = Enumerable.Range(0, threadCount).Select(_ => new Thread(RunLoop) { Name = threadName }).ToArray();
+            foreach (var t in _Threads)
+                t.Start();
+        }
+
+        public void Do(Action act)
+        {
+            DoAsync(act).GetAwaiter().GetResult();
+        }
+
+        public T Do<T>(Func<T> act)
+        {
+            return DoAsync(act).GetAwaiter().GetResult();
+        }
+
+        public async Task<T> DoAsync<T>(Func<T> act)
+        {
+            TaskCompletionSource<object> done = new TaskCompletionSource<object>();
+            _Actions.Add((() =>
+            {
+                try
+                {
+                    done.TrySetResult(act());
+                }
+                catch (Exception ex) { done.TrySetException(ex); }
+            }
+            , done));
+            return (T)(await done.Task.ConfigureAwait(false));
+        }
+
+        public Task DoAsync(Action act)
+        {
+            return DoAsync<object>(() =>
+            {
+                act();
+                return null;
+            });
+        }
+
+        void RunLoop()
+        {
+            try
+            {
+                foreach (var act in _Actions.GetConsumingEnumerable(_Cancel.Token))
+                {
+                    act.Item1();
+                }
+            }
+            catch (OperationCanceledException) when (_Cancel.IsCancellationRequested) { }
+            catch (Exception ex)
+            {
+                _Cancel.Cancel();
+                _UnhandledException = ex;
+            }
+            if (Interlocked.Increment(ref _ExitedCount) == _Threads.Length)
+            {
+                foreach (var action in _Actions)
+                {
+                    try
+                    {
+                        action.Item2.TrySetCanceled();
+                    }
+                    catch { }
+                }
+                _Exited.TrySetResult(true);
+            }
+        }
+
+        public void Dispose()
+        {
+            _Cancel.Cancel();
+            _Exited.Task.GetAwaiter().GetResult();
+        }
+    }
+}

BTCPayServer/Data/InvoiceData.cs

@@ -71,5 +71,9 @@ namespace BTCPayServer.Data
             get;
             set;
         }
+        public List<AddressInvoiceData> AddressInvoices
+        {
+            get; set;
+        }
     }
 }

BTCPayServer/Data/PaymentData.cs

@@ -25,5 +25,9 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
+        public bool Accounted
+        {
+            get; set;
+        }
     }
 }

BTCPayServer/Data/StoreData.cs

@@ -8,6 +8,8 @@ using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.ComponentModel;
+using Newtonsoft.Json;
 
 namespace BTCPayServer.Data
 {
@@ -65,17 +67,33 @@ namespace BTCPayServer.Data
             return StoreBlob == null ? new StoreBlob() : new Serializer(network).ToObject<StoreBlob>(Encoding.UTF8.GetString(StoreBlob));
         }
 
-        public void SetStoreBlob(StoreBlob storeBlob, Network network)
+        public bool SetStoreBlob(StoreBlob storeBlob, Network network)
         {
-            StoreBlob = Encoding.UTF8.GetBytes(new Serializer(network).ToString(storeBlob));
+            var original = new Serializer(network).ToString(GetStoreBlob(network));
+            var newBlob = new Serializer(network).ToString(storeBlob);
+            if (original == newBlob)
+                return false;
+            StoreBlob = Encoding.UTF8.GetBytes(newBlob);
+            return true;
         }
     }
 
     public class StoreBlob
     {
+        public StoreBlob()
+        {
+            MonitoringExpiration = 60;
+        }
         public bool NetworkFeeDisabled
         {
             get; set;
         }
+        [DefaultValue(60)]
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        public int MonitoringExpiration
+        {
+            get;
+            set;
+        }
     }
 }

BTCPayServer/Extensions.cs

@@ -11,11 +11,26 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Text.Encodings.Web;
+using NBitcoin;
+using System.Threading.Tasks;
+using NBXplorer;
+using NBXplorer.Models;
+using System.Linq;
+using System.Threading;
 
 namespace BTCPayServer
 {
     public static class Extensions
     {
+        public static async Task<Dictionary<uint256, TransactionResult>> GetTransactions(this ExplorerClient client, uint256[] hashes, CancellationToken cts = default(CancellationToken))
+        {
+            hashes = hashes.Distinct().ToArray();
+            var transactions = hashes
+                                        .Select(async o => await client.GetTransactionAsync(o, cts))
+                                        .ToArray();
+            await Task.WhenAll(transactions).ConfigureAwait(false);
+            return transactions.Select(t => t.Result).Where(t => t != null).ToDictionary(o => o.Transaction.GetHash());
+        }
         public static string WithTrailingSlash(this string str)
         {
             if (str.EndsWith("/"))

BTCPayServer/Hosting/BTCpayMiddleware.cs

@@ -30,13 +30,16 @@ namespace BTCPayServer.Hosting
         TokenRepository _TokenRepository;
         RequestDelegate _Next;
         CallbackController _CallbackController;
+        BTCPayServerOptions _Options;
         public BTCPayMiddleware(RequestDelegate next,
             TokenRepository tokenRepo,
+            BTCPayServerOptions options,
             CallbackController callbackController)
         {
             _TokenRepository = tokenRepo ?? throw new ArgumentNullException(nameof(tokenRepo));
             _Next = next ?? throw new ArgumentNullException(nameof(next));
             _CallbackController = callbackController;
+            _Options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
 
@@ -50,6 +53,16 @@ namespace BTCPayServer.Hosting
                 _Registered = true;
             }
 
+            // Make sure that code executing after this point think that the external url has been hit.
+            if(_Options.ExternalUrl != null)
+            {
+                httpContext.Request.Scheme = _Options.ExternalUrl.Scheme;
+                if(_Options.ExternalUrl.IsDefaultPort)
+                    httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host);
+                else
+                    httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, _Options.ExternalUrl.Port);
+            }
+
             httpContext.Request.Headers.TryGetValue("x-signature", out StringValues values);
             var sig = values.FirstOrDefault();
             httpContext.Request.Headers.TryGetValue("x-identity", out values);

BTCPayServer/Migrations/20171105235734_PaymentAccounted.Designer.cs

@@ -0,0 +1,479 @@
+// <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("20171105235734_PaymentAccounted")]
+    partial class PaymentAccounted
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.0-rtm-26452");
+
+            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<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>("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()
+                        .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/20171105235734_PaymentAccounted.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class PaymentAccounted : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "Accounted",
+                table: "Payments",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Accounted",
+                table: "Payments");
+        }
+    }
+}

BTCPayServer/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -132,6 +132,8 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("Id")
                         .ValueGeneratedOnAdd();
 
+                    b.Property<bool>("Accounted");
+
                     b.Property<byte[]>("Blob");
 
                     b.Property<string>("InvoiceDataId");

BTCPayServer/Models/InvoicingModels/CreateInvoiceModel.cs

@@ -9,12 +9,22 @@ namespace BTCPayServer.Models.InvoicingModels
 {
     public class CreateInvoiceModel
     {
+        public CreateInvoiceModel()
+        {
+            Currency = "USD";
+        }
         [Required]
         public double? Amount
         {
             get; set;
         }
 
+        [Required]
+        public string Currency
+        {
+            get; set;
+        }
+
         [Required]
         public string StoreId
         {

BTCPayServer/Models/ServerViewModels/UsersViewModel.cs

@@ -9,6 +9,7 @@ namespace BTCPayServer.Models.ServerViewModels
     {
         public class UserViewModel
         {
+            public string Id { get; set; }
             public string Name
             {
                 get; set;

BTCPayServer/Models/StoreViewModels/StoreViewModel.cs

@@ -10,6 +10,7 @@ namespace BTCPayServer.Models.StoreViewModels
 {
     public class StoreViewModel
     {
+        public string Id { get; set; }
         [Display(Name = "Store Name")]
         [Required]
         [MaxLength(50)]
@@ -34,6 +35,14 @@ namespace BTCPayServer.Models.StoreViewModels
             get; set;
         }
 
+        [Display(Name = "Payment invalid if transactions fails to confirm after ... minutes")]
+        [Range(10, 60 * 24 * 31)]
+        public int MonitoringExpiration
+        {
+            get;
+            set;
+        }
+
         [Display(Name = "Consider the invoice confirmed when the payment transaction...")]
         public SpeedPolicy SpeedPolicy
         {

BTCPayServer/SearchString.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace BTCPayServer
+{
+    public class SearchString
+    {
+        string _OriginalString;
+        public SearchString(string str)
+        {
+            str = str ?? string.Empty;
+            str = str.Trim();
+            _OriginalString = str.Trim();
+            TextSearch = _OriginalString;
+            var splitted = str.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
+            Filters
+                = splitted
+                    .Select(t => t.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries))
+                    .Where(kv => kv.Length == 2)
+                    .Select(kv => new KeyValuePair<string, string>(kv[0].ToLowerInvariant(), kv[1]))
+                    .ToDictionary(o => o.Key, o => o.Value);
+
+            foreach(var filter in splitted)
+            {
+                if(filter.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Length == 2)
+                { 
+                    TextSearch = TextSearch.Replace(filter, string.Empty);
+                }
+            }
+            TextSearch = TextSearch.Trim();
+        }
+
+        public string TextSearch
+        {
+            get;
+            private set;
+        }
+
+        public Dictionary<string, string> Filters { get; private set; }
+
+        public override string ToString()
+        {
+            return _OriginalString;
+        }
+    }
+}

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -9,6 +9,7 @@ using NBitpayClient;
 using Newtonsoft.Json.Linq;
 using NBitcoin.DataEncoders;
 using BTCPayServer.Data;
+using NBXplorer.Models;
 
 namespace BTCPayServer.Services.Invoices
 {
@@ -132,6 +133,7 @@ namespace BTCPayServer.Services.Invoices
             int txCount = 1;
             var payments =
                 Payments
+                .Where(p => p.Accounted)
                 .OrderByDescending(p => p.ReceivedTime)
                 .Select(_ =>
                 {
@@ -249,7 +251,8 @@ namespace BTCPayServer.Services.Invoices
             get;
             set;
         }
-        public DateTimeOffset? MonitoringExpiration
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        public DateTimeOffset MonitoringExpiration
         {
             get;
             set;
@@ -260,6 +263,12 @@ namespace BTCPayServer.Services.Invoices
             set;
         }
 
+        public HashSet<string> AvailableAddressHashes
+        {
+            get;
+            set;
+        }
+
         public bool IsExpired()
         {
             return DateTimeOffset.UtcNow > ExpirationTime;
@@ -300,7 +309,7 @@ namespace BTCPayServer.Services.Invoices
             dto.Token = Encoders.Base58.EncodeData(RandomUtils.GetBytes(16)); //No idea what it is useful for
             dto.Guid = Guid.NewGuid().ToString();
 
-            var paid = Payments.Select(p => p.Output.Value).Sum();
+            var paid = Payments.Where(p => p.Accounted).Select(p => p.Output.Value).Sum();
             dto.BTCPaid = paid.ToString();
             dto.BTCDue = GetCryptoDue().ToString();
 
@@ -321,6 +330,17 @@ namespace BTCPayServer.Services.Invoices
         }
     }
 
+    public class AccountedPaymentEntity
+    {
+        public int Confirmations
+        {
+            get;
+            set;
+        }
+        public PaymentEntity Payment { get; set; }
+        public Transaction Transaction { get; set; }
+    }
+
     public class PaymentEntity
     {
         public DateTimeOffset ReceivedTime
@@ -335,5 +355,9 @@ namespace BTCPayServer.Services.Invoices
         {
             get; set;
         }
+        public bool Accounted
+        {
+            get; set;
+        }
     }
 }

BTCPayServer/Services/Invoices/InvoiceRepository.cs

@@ -19,7 +19,7 @@ using BTCPayServer.Models.InvoicingModels;
 
 namespace BTCPayServer.Services.Invoices
 {
-    public class InvoiceRepository
+    public class InvoiceRepository : IDisposable
     {
 
 
@@ -45,24 +45,17 @@ namespace BTCPayServer.Services.Invoices
                 _Network = value;
             }
         }
-
+        
         private ApplicationDbContextFactory _ContextFactory;
-        public InvoiceRepository(ApplicationDbContextFactory contextFactory, DBreezeEngine engine, Network network)
+        private CustomThreadPool _IndexerThread;
+        public InvoiceRepository(ApplicationDbContextFactory contextFactory, string dbreezePath, Network network)
         {
-            _Engine = engine;
+            _Engine = new DBreezeEngine(dbreezePath);
+            _IndexerThread = new CustomThreadPool(1, "Invoice Indexer");
             _Network = network;
             _ContextFactory = contextFactory;
         }
 
-        public async Task AddPendingInvoice(string invoiceId)
-        {
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                ctx.PendingInvoices.Add(new PendingInvoiceData() { Id = invoiceId });
-                await ctx.SaveChangesAsync();
-            }
-        }
-
         public async Task<bool> RemovePendingInvoice(string invoiceId)
         {
             using (var ctx = _ContextFactory.CreateContext())
@@ -117,7 +110,7 @@ namespace BTCPayServer.Services.Invoices
             invoice.StoreId = storeId;
             using (var context = _ContextFactory.CreateContext())
             {
-                await context.AddAsync(new InvoiceData()
+                context.Invoices.Add(new InvoiceData()
                 {
                     StoreDataId = storeId,
                     Id = invoice.Id,
@@ -127,21 +120,20 @@ namespace BTCPayServer.Services.Invoices
                     Status = invoice.Status,
                     ItemCode = invoice.ProductInformation.ItemCode,
                     CustomerEmail = invoice.RefundMail
-                }).ConfigureAwait(false);
-
+                });
                 context.AddressInvoices.Add(new AddressInvoiceData()
                 {
                     Address = invoice.DepositAddress.ScriptPubKey.Hash.ToString(),
                     InvoiceDataId = invoice.Id,
                     CreatedTime = DateTimeOffset.UtcNow,
                 });
-
                 context.HistoricalAddressInvoices.Add(new HistoricalAddressInvoiceData()
                 {
                     InvoiceDataId = invoice.Id,
                     Address = invoice.DepositAddress.ToString(),
                     Assigned = DateTimeOffset.UtcNow
                 });
+                context.PendingInvoices.Add(new PendingInvoiceData() { Id = invoice.Id });
                 await context.SaveChangesAsync().ConfigureAwait(false);
             }
 
@@ -231,11 +223,14 @@ namespace BTCPayServer.Services.Invoices
 
         void AddToTextSearch(string invoiceId, params string[] terms)
         {
-            using (var tx = _Engine.GetTransaction())
+            _IndexerThread.DoAsync(() => 
             {
-                tx.TextInsert("InvoiceSearch", Encoders.Base58.DecodeData(invoiceId), string.Join(" ", terms.Where(t => !String.IsNullOrWhiteSpace(t))));
-                tx.Commit();
-            }
+                using (var tx = _Engine.GetTransaction())
+                {
+                    tx.TextInsert("InvoiceSearch", Encoders.Base58.DecodeData(invoiceId), string.Join(" ", terms.Where(t => !String.IsNullOrWhiteSpace(t))));
+                    tx.Commit();
+                }
+            });
         }
 
         public async Task UpdateInvoiceStatus(string invoiceId, string status, string exceptionStatus)
@@ -251,7 +246,18 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        public async Task<InvoiceEntity> GetInvoice(string storeId, string id, bool includeHistoricalAddresses = false)
+        public async Task UpdatePaidInvoiceToInvalid(string invoiceId)
+        {
+            using (var context = _ContextFactory.CreateContext())
+            {
+                var invoiceData = await context.FindAsync<InvoiceData>(invoiceId).ConfigureAwait(false);
+                if (invoiceData?.Status != "paid")
+                    return;
+                invoiceData.Status = "invalid";
+                await context.SaveChangesAsync().ConfigureAwait(false);
+            }
+        }
+        public async Task<InvoiceEntity> GetInvoice(string storeId, string id, bool inludeAddressData = false)
         {
             using (var context = _ContextFactory.CreateContext())
             {
@@ -260,8 +266,8 @@ namespace BTCPayServer.Services.Invoices
                     .Invoices
                     .Include(o => o.Payments)
                     .Include(o => o.RefundAddresses);
-                if (includeHistoricalAddresses)
-                    query = query.Include(o => o.HistoricalAddressInvoices);
+                if (inludeAddressData)
+                    query = query.Include(o => o.HistoricalAddressInvoices).Include(o => o.AddressInvoices);
                 query = query.Where(i => i.Id == id);
 
                 if (storeId != null)
@@ -278,7 +284,12 @@ namespace BTCPayServer.Services.Invoices
         private InvoiceEntity ToEntity(InvoiceData invoice)
         {
             var entity = ToObject<InvoiceEntity>(invoice.Blob);
-            entity.Payments = invoice.Payments.Select(p => ToObject<PaymentEntity>(p.Blob)).ToList();
+            entity.Payments = invoice.Payments.Select(p => 
+            {
+                var paymentEntity = ToObject<PaymentEntity>(p.Blob);
+                paymentEntity.Accounted = p.Accounted;
+                return paymentEntity;
+            }).ToList();
             entity.ExceptionStatus = invoice.ExceptionStatus;
             entity.Status = invoice.Status;
             entity.RefundMail = invoice.CustomerEmail;
@@ -287,6 +298,10 @@ namespace BTCPayServer.Services.Invoices
             {
                 entity.HistoricalAddresses = invoice.HistoricalAddressInvoices.ToArray();
             }
+            if (invoice.AddressInvoices != null)
+            {
+                entity.AvailableAddressHashes = invoice.AddressInvoices.Select(a => a.Address).ToHashSet();
+            }
             return entity;
         }
 
@@ -364,12 +379,12 @@ namespace BTCPayServer.Services.Invoices
                 int i = 0;
                 foreach (var output in outputs)
                 {
-                    await context.RefundAddresses.AddAsync(new RefundAddressesData()
+                    context.RefundAddresses.Add(new RefundAddressesData()
                     {
                         Id = invoiceId + "-" + i,
                         InvoiceDataId = invoiceId,
                         Blob = ToBytes(output)
-                    }).ConfigureAwait(false);
+                    });
                     i++;
                 }
                 await context.SaveChangesAsync().ConfigureAwait(false);
@@ -397,13 +412,32 @@ namespace BTCPayServer.Services.Invoices
                     InvoiceDataId = invoiceId
                 };
 
-                await context.Payments.AddAsync(data).ConfigureAwait(false);
+                context.Payments.Add(data);
 
                 await context.SaveChangesAsync().ConfigureAwait(false);
+                AddToTextSearch(invoiceId, receivedCoin.Outpoint.Hash.ToString());
                 return entity;
             }
         }
 
+        public async Task UpdatePayments(List<AccountedPaymentEntity> payments)
+        {
+            if (payments.Count == 0)
+                return;
+            using (var context = _ContextFactory.CreateContext())
+            {
+                foreach (var payment in payments)
+                {
+                    var data = new PaymentData();
+                    data.Id = payment.Payment.Outpoint.ToString();
+                    data.Accounted = payment.Payment.Accounted;
+                    context.Attach(data);
+                    context.Entry(data).Property(o => o.Accounted).IsModified = true;
+                }
+                await context.SaveChangesAsync().ConfigureAwait(false);
+            }
+        }
+
         private T ToObject<T>(byte[] value)
         {
             return NBitcoin.JsonConverters.Serializer.ToObject<T>(ZipUtils.Unzip(value), Network);
@@ -423,6 +457,14 @@ namespace BTCPayServer.Services.Invoices
         {
             return NBitcoin.JsonConverters.Serializer.ToString(data, Network);
         }
+
+        public void Dispose()
+        {
+            if (_Engine != null)
+                _Engine.Dispose();
+            if (_IndexerThread != null)
+                _IndexerThread.Dispose();
+        }
     }
 
     public class InvoiceQuery

BTCPayServer/Services/Invoices/InvoiceWatcher.cs

@@ -65,7 +65,7 @@ namespace BTCPayServer.Services.Invoices
             {
                 try
                 {
-                    var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId).ConfigureAwait(false);
+                    var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, true).ConfigureAwait(false);
                     if (invoice == null)
                         break;
                     var stateBefore = invoice.Status;
@@ -80,9 +80,8 @@ namespace BTCPayServer.Services.Invoices
                         Logs.PayServer.LogInformation($"Invoice {invoice.Id}: {stateBefore} => {invoice.Status}");
                     }
 
-                    var expirationMonitoring = invoice.MonitoringExpiration.HasValue ? invoice.MonitoringExpiration.Value : invoice.InvoiceTime + TimeSpan.FromMinutes(60);
                     if (invoice.Status == "complete" ||
-                       ((invoice.Status == "invalid" || invoice.Status == "expired") && expirationMonitoring < DateTimeOffset.UtcNow))
+                       ((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);
@@ -113,28 +112,18 @@ namespace BTCPayServer.Services.Invoices
             changes = await _ExplorerClient.SyncAsync(strategy, changes, !LongPollingMode, _Cts.Token).ConfigureAwait(false);
 
             var utxos = changes.Confirmed.UTXOs.Concat(changes.Unconfirmed.UTXOs).ToArray();
-            var invoiceIds = utxos.Select(u => _InvoiceRepository.GetInvoiceIdFromScriptPubKey(u.Output.ScriptPubKey)).ToArray();
-            utxos =
-                utxos
-                .Where((u, i) => invoiceIds[i].GetAwaiter().GetResult() == invoice.Id)
-                .ToArray();
-
             List<Coin> receivedCoins = new List<Coin>();
             foreach (var received in utxos)
-                if (received.Output.ScriptPubKey == invoice.DepositAddress.ScriptPubKey)
+                if (invoice.AvailableAddressHashes.Contains(received.Output.ScriptPubKey.Hash.ToString()))
                     receivedCoins.Add(new Coin(received.Outpoint, received.Output));
 
             var alreadyAccounted = new HashSet<OutPoint>(invoice.Payments.Select(p => p.Outpoint));
-            BitcoinAddress generatedAddress = null;
             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);
-                if (coin.ScriptPubKey == invoice.DepositAddress.ScriptPubKey && generatedAddress == null)
-                {
-                    dirtyAddress = true;
-                }
+                dirtyAddress = true;
             }
             //////
 
@@ -143,11 +132,15 @@ namespace BTCPayServer.Services.Invoices
                 needSave = true;
                 await _InvoiceRepository.UnaffectAddress(invoice.Id);
                 invoice.Status = "expired";
+                if (invoice.FullNotifications)
+                {
+                    _NotificationManager.Notify(invoice);
+                }
             }
 
             if (invoice.Status == "new" || invoice.Status == "expired")
             {
-                var totalPaid = invoice.Payments.Select(p => p.Output.Value).Sum();
+                var totalPaid = (await GetPaymentsWithTransaction(invoice)).Select(p => p.Payment.Output.Value).Sum();
                 if (totalPaid >= invoice.GetTotalCryptoDue())
                 {
                     if (invoice.Status == "new")
@@ -191,22 +184,39 @@ namespace BTCPayServer.Services.Invoices
 
             if (invoice.Status == "paid")
             {
-                if (!invoice.MonitoringExpiration.HasValue || invoice.MonitoringExpiration > DateTimeOffset.UtcNow)
+                var transactions = await GetPaymentsWithTransaction(invoice);
+                var chainConfirmedTransactions = transactions.Where(t => t.Confirmations >= 1);
+                if (invoice.SpeedPolicy == SpeedPolicy.HighSpeed)
                 {
-                    var transactions = await GetPaymentsWithTransaction(invoice);
-                    if (invoice.SpeedPolicy == SpeedPolicy.HighSpeed)
-                    {
-                        transactions = transactions.Where(t => !t.Transaction.Transaction.RBF);
-                    }
-                    else if (invoice.SpeedPolicy == SpeedPolicy.MediumSpeed)
-                    {
-                        transactions = transactions.Where(t => t.Transaction.Confirmations >= 1);
-                    }
-                    else if (invoice.SpeedPolicy == SpeedPolicy.LowSpeed)
-                    {
-                        transactions = transactions.Where(t => t.Transaction.Confirmations >= 6);
-                    }
+                    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.Output.Value).Sum();
+
+                if (// Is after the monitoring deadline
+                   (invoice.MonitoringExpiration < DateTimeOffset.UtcNow)
+                   &&
+                   // And not enough amount confirmed
+                   (chainTotalConfirmed < invoice.GetTotalCryptoDue()))
+                {
+                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                    invoice.Status = "invalid";
+                    needSave = true;
+                    if (invoice.FullNotifications)
+                    {
+                        _NotificationManager.Notify(invoice);
+                    }
+                }
+                else
+                {
                     var totalConfirmed = transactions.Select(t => t.Payment.Output.Value).Sum();
                     if (totalConfirmed >= invoice.GetTotalCryptoDue())
                     {
@@ -216,18 +226,12 @@ namespace BTCPayServer.Services.Invoices
                         needSave = true;
                     }
                 }
-                else
-                {
-                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                    invoice.Status = "invalid";
-                    needSave = true;
-                }
             }
 
             if (invoice.Status == "confirmed")
             {
                 var transactions = await GetPaymentsWithTransaction(invoice);
-                transactions = transactions.Where(t => t.Transaction.Confirmations >= 6);
+                transactions = transactions.Where(t => t.Confirmations >= 6);
                 var totalConfirmed = transactions.Select(t => t.Payment.Output.Value).Sum();
                 if (totalConfirmed >= invoice.GetTotalCryptoDue())
                 {
@@ -237,18 +241,62 @@ namespace BTCPayServer.Services.Invoices
                     needSave = true;
                 }
             }
-
             return (needSave, changes);
         }
 
-        private async Task<IEnumerable<(PaymentEntity Payment, TransactionResult Transaction)>> GetPaymentsWithTransaction(InvoiceEntity invoice)
+        private async Task<IEnumerable<AccountedPaymentEntity>> GetPaymentsWithTransaction(InvoiceEntity invoice)
         {
-            var getPayments = invoice.Payments
-                                                 .Select(async o => (Payment: o, Transaction: await _ExplorerClient.GetTransactionAsync(o.Outpoint.Hash, _Cts.Token)))
-                                                 .ToArray();
-            await Task.WhenAll(getPayments).ConfigureAwait(false);
-            var transactions = getPayments.Select(c => (Payment: c.Result.Payment, Transaction: c.Result.Transaction));
-            return transactions;
+            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;
@@ -268,12 +316,10 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        public async Task WatchAsync(string invoiceId, bool singleShot = false)
+        public void Watch(string invoiceId)
         {
             if (invoiceId == null)
                 throw new ArgumentNullException(nameof(invoiceId));
-            if (!singleShot)
-                await _InvoiceRepository.AddPendingInvoice(invoiceId).ConfigureAwait(false);
             _WatchRequests.Add(invoiceId);
         }
 

BTCPayServer/Services/PoliciesSettings.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
 
 namespace BTCPayServer.Services
 {
@@ -11,5 +12,8 @@ namespace BTCPayServer.Services
         {
             get; set;
         }
+
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        public bool LockSubscription { get; set; }
     }
 }

BTCPayServer/Services/Rates/CoinAverageRateProvider.cs

@@ -66,7 +66,7 @@ namespace BTCPayServer.Services.Rates
                 {
                     var rateJson = new RateJson();
                     rateJson.Code = rate.Name;
-                    rateJson.Rate = rate.Value["rate"].Value<decimal>();
+                    rateJson.Rate = decimal.Parse(rate.Value["rate"].Value<string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint);
                     RatesByCurrency.Add(rate.Name, rateJson.Rate);
                     Rates.Add(rateJson);
                 }

BTCPayServer/Services/Stores/StoreRepository.cs

@@ -76,8 +76,8 @@ namespace BTCPayServer.Services.Stores
                     ApplicationUserId = ownerId,
                     Role = "Owner"
                 };
-                await ctx.AddAsync(store).ConfigureAwait(false);
-                await ctx.AddAsync(userStore).ConfigureAwait(false);
+                ctx.Add(store);
+                ctx.Add(userStore);
                 await ctx.SaveChangesAsync().ConfigureAwait(false);
                 return store;
             }

BTCPayServer/TransactionComparer.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public class TransactionComparer : IEqualityComparer<Transaction>
+    {
+
+        private static TransactionComparer _Instance = new TransactionComparer();
+        public static TransactionComparer Instance
+        {
+            get
+            {
+                return _Instance;
+            }
+        }
+        public bool Equals(Transaction x, Transaction y)
+        {
+            return x.GetHash() == y.GetHash();
+        }
+
+        public int GetHashCode(Transaction obj)
+        {
+            return obj.GetHash().GetHashCode();
+        }
+    }
+}

BTCPayServer/Views/Invoice/Checkout.cshtml

@@ -10,7 +10,7 @@
     <!-- base href="/" -->
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <title>BitPay Invoice</title>
+    <title>BTCPay Invoice</title>
 
     <environment include="Development">
         <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.css" />

BTCPayServer/Views/Invoice/CreateInvoice.cshtml

@@ -19,6 +19,11 @@
                         <input asp-for="Amount" class="form-control" />
                         <span asp-validation-for="Amount" class="text-danger"></span>
                     </div>
+                    <div class="form-group">
+                        <label asp-for="Currency" class="control-label"></label>*
+                        <input asp-for="Currency" class="form-control" />
+                        <span asp-validation-for="Currency" class="text-danger"></span>
+                    </div>
                     <div class="form-group">
                         <label asp-for="OrderId" class="control-label"></label>
                         <input asp-for="OrderId" class="form-control" />

BTCPayServer/Views/Invoice/ListInvoices.cshtml

@@ -16,13 +16,21 @@
             <div class="col-lg-12 text-center">
                 <h2 class="section-heading">@ViewData["Title"]</h2>
                 <hr class="primary">
-                <p>Create, search or pay an invoice.</p>
+                <p>Create, search or pay an invoice. (<a href="#help" data-toggle="collapse">Help</a>)</p>
+                <div id="help" class="collapse text-left">
+                    <p>You can search for invoice Id, deposit address, price, order id, store id, any buyer information and any product information.</br>
+                    You can also apply filters to your search by searching for `filtername:value`, here is a list of supported filters</p>
+                    <ul>
+                        <li><b>storeid:id</b> for filtering a specific store</li>
+                        <li><b>status:(expired|invalid|complete|confirmed|paid|new)</b> for filtering a specific status</li>
+                    </ul>
+                </div>
                 <div class="form-group">
                     <form asp-action="SearchInvoice" method="post">
                         <input asp-for="SearchTerm" class="form-control" />
                         <input type="hidden" asp-for="Count" />
                         <span asp-validation-for="SearchTerm" class="text-danger"></span>
-                        <button type="button" class="btn btn-default" title="Search invoice">
+                        <button type="submit" class="btn btn-default" title="Search invoice">
                             <span class="glyphicon glyphicon-search"></span> Search
                         </button>
                     </form>
@@ -48,7 +56,23 @@
                         <tr>
                             <td>@invoice.Date</td>
                             <td>@invoice.InvoiceId</td>
-                            <td>@invoice.Status</td>
+                            @if(invoice.Status == "paid")
+                            {
+                                <td>
+                                    <div class="btn-group">
+                                        <a class="dropdown-toggle dropdown-toggle-split" style="cursor: pointer;" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
+                                            @invoice.Status <span class="sr-only">Toggle Dropdown</span>
+                                        </a>
+                                        <div class="dropdown-menu pull-right">
+                                            <button class="dropdown-item small" data-toggle="modal" data-target="#myModal" onclick="$('#invoiceId').val('@invoice.InvoiceId')">Make Invalid</button>
+                                        </div>
+                                    </div>
+                                </td>
+                            }
+                            else
+                            {
+                                <td>@invoice.Status</td>
+                            }
                             <td>@invoice.AmountCurrency</td>
                             <td><a asp-action="Checkout" asp-route-invoiceId="@invoice.InvoiceId">Checkout</a> - <a asp-action="Invoice" asp-route-invoiceId="@invoice.InvoiceId">Details</a></td>
                         </tr>
@@ -59,20 +83,45 @@
                 @if(Model.Skip != 0)
                 {
                     <a href="@Url.Action("ListInvoices", new
-		{
-			searchTerm = Model.SearchTerm,
-			skip = Math.Max(0, Model.Skip - Model.Count),
-			count = Model.Count,
-		})"><<</a><span> - </span>
+                        {
+                            searchTerm = Model.SearchTerm,
+                            skip = Math.Max(0, Model.Skip - Model.Count),
+                            count = Model.Count,
+                        })"><<</a><span> - </span>
                 }
                 <a href="@Url.Action("ListInvoices", new
-		{
-			searchTerm = Model.SearchTerm,
-			skip = Model.Skip + Model.Count,
-			count = Model.Count,
-		})">>></a>
+                    {
+                        searchTerm = Model.SearchTerm,
+                        skip = Model.Skip + Model.Count,
+                        count = Model.Count,
+                    })">>></a>
             </span>
         </div>
 
     </div>
 </section>
+
+<!-- Modal -->
+<div id="myModal" class="modal fade" role="dialog">
+    <form method="post" action="/invoices/invalidatepaid">
+        <input id="invoiceId" name="invoiceId" type="hidden" />
+        <div class="modal-dialog">
+
+            <!-- Modal content-->
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h4 class="modal-title">Set Invoice status to Invalid</h4>
+                    <button type="button" class="close" data-dismiss="modal">&times;</button>
+                </div>
+                <div class="modal-body">
+                    <p>Are you sure you want to invalidate this transaction? This action is NOT undoable!</p>
+                </div>
+                <div class="modal-footer">
+                    <button type="submit" class="btn btn-danger">Yes, make invoice Invalid</button>
+                    <button type="button" class="btn btn-default" data-dismiss="modal">Cancel</button>
+                </div>
+            </div>
+
+        </div>
+    </form>
+</div>

BTCPayServer/Views/Server/ListUsers.cshtml

@@ -14,6 +14,7 @@
         <tr>
             <th>Name</th>
             <th>Email</th>
+            <th>Actions</th>
         </tr>
     </thead>
     <tbody>
@@ -22,6 +23,7 @@
             <tr>
                 <td>@user.Name</td>
                 <td>@user.Email</td>
+                <td><a asp-action="DeleteUser" asp-route-userId="@user.Id">Remove</a></td>
             </tr>}
     </tbody>
 </table>

BTCPayServer/Views/Server/Policies.cshtml

@@ -19,6 +19,10 @@
                 <label asp-for="RequiresConfirmedEmail"></label>
                 <input asp-for="RequiresConfirmedEmail" type="checkbox" class="form-check-inline" />
             </div>
+            <div class="form-group">
+                <label asp-for="LockSubscription"></label>
+                <input asp-for="LockSubscription" type="checkbox" class="form-check-inline" />
+            </div>
             <button type="submit" class="btn btn-success" name="command" value="Save">Save</button>
         </form>
     </div>

BTCPayServer/Views/Stores/UpdateStore.cshtml

@@ -16,6 +16,15 @@
 <div class="row">
     <div class="col-md-6">
         <form method="post">
+            <div class="form-group">
+                <label asp-for="Id"></label>
+                <input asp-for="Id" readonly class="form-control" />
+            </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="StoreName"></label>
                 <input asp-for="StoreName" class="form-control" />
@@ -30,6 +39,11 @@
                 <label asp-for="NetworkFee"></label>
                 <input asp-for="NetworkFee" type="checkbox" class="form-check" />
             </div>
+            <div class="form-group">
+                <label asp-for="MonitoringExpiration"></label>
+                <input asp-for="MonitoringExpiration" class="form-control" />
+                <span asp-validation-for="MonitoringExpiration" class="text-danger"></span>
+            </div>
             <div class="form-group">
                 <label asp-for="SpeedPolicy"></label>
                 <select asp-for="SpeedPolicy" class="form-control">

btcpayserver.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26730.16
+VisualStudioVersion = 15.0.27004.2005
 MinimumVisualStudioVersion = 15.0.26124.0
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BTCPayServer", "BTCPayServer\BTCPayServer.csproj", "{949A0870-8D8C-4DE5-8845-DDD560489177}"
 EndProject