Change address if invoice get partially paid

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -121,6 +121,11 @@ namespace BTCPayServer.Tests
 			internal set;
 		}
 
+		public T GetService<T>()
+		{
+			return _Host.Services.GetRequiredService<T>();
+		}
+
 		public T GetController<T>(string userId = null) where T : Controller
 		{
 			var context = new DefaultHttpContext();

BTCPayServer.Tests/UnitTest1.cs

@@ -17,6 +17,9 @@ using BTCPayServer.Controllers;
 using Microsoft.AspNetCore.Mvc;
 using BTCPayServer.Authentication;
 using System.Diagnostics;
+using Microsoft.EntityFrameworkCore.Extensions;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
 
 namespace BTCPayServer.Tests
 {
@@ -193,143 +196,169 @@ namespace BTCPayServer.Tests
         public void InvoiceFlowThroughDifferentStatesCorrectly()
         {
             using (var tester = ServerTester.Create())
-            {
-                tester.Start();
-                var user = tester.NewAccount();
-                Assert.False(user.BitPay.TestAccess(Facade.Merchant));
-                user.GrantAccess();
-                Assert.True(user.BitPay.TestAccess(Facade.Merchant));
-                var invoice = user.BitPay.CreateInvoice(new Invoice()
-                {
-                    Price = 5000.0,
-                    Currency = "USD",
-                    PosData = "posData",
-                    OrderId = "orderId",
-                    //RedirectURL = redirect + "redirect",
-                    //NotificationURL = CallbackUri + "/notification",
-                    ItemDesc = "Some description",
-                    FullNotifications = true
-                }, Facade.Merchant);
+			{
+				tester.Start();
+				var user = tester.NewAccount();
+				Assert.False(user.BitPay.TestAccess(Facade.Merchant));
+				user.GrantAccess();
+				Assert.True(user.BitPay.TestAccess(Facade.Merchant));
+				var invoice = user.BitPay.CreateInvoice(new Invoice()
+				{
+					Price = 5000.0,
+					Currency = "USD",
+					PosData = "posData",
+					OrderId = "orderId",
+					//RedirectURL = redirect + "redirect",
+					//NotificationURL = CallbackUri + "/notification",
+					ItemDesc = "Some description",
+					FullNotifications = true
+				}, Facade.Merchant);
+				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();
 
-                var textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
-                {
-                    StoreId = user.StoreId,
-                    TextSearch = invoice.OrderId
-                }).GetAwaiter().GetResult();
+				Assert.Equal(1, textSearchResult.Length);
 
-                Assert.Equal(1, textSearchResult.Length);
+				textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
+				{
+					StoreId = user.StoreId,
+					TextSearch = invoice.Id
+				}).GetAwaiter().GetResult();
 
-                textSearchResult = tester.PayTester.Runtime.InvoiceRepository.GetInvoices(new InvoiceQuery()
-                {
-                    StoreId = user.StoreId,
-                    TextSearch = invoice.Id
-                }).GetAwaiter().GetResult();
+				Assert.Equal(1, textSearchResult.Length);
 
-                Assert.Equal(1, textSearchResult.Length);
+				invoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
+				Assert.Equal(Money.Coins(0), invoice.BtcPaid);
+				Assert.Equal("new", invoice.Status);
+				Assert.Equal(false, (bool)((JValue)invoice.ExceptionStatus).Value);
 
-                invoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
-                Assert.Equal(Money.Coins(0), invoice.BtcPaid);
-                Assert.Equal("new", invoice.Status);
-                Assert.Equal(false, (bool)((JValue)invoice.ExceptionStatus).Value);
-
-                Assert.Equal(1, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime).Length);
-                Assert.Equal(0, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime + TimeSpan.FromDays(1)).Length);
-                Assert.Equal(1, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5)).Length);
-                Assert.Equal(1, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime).Length);
-                Assert.Equal(0, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime - TimeSpan.FromDays(1)).Length);
+				Assert.Equal(1, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime).Length);
+				Assert.Equal(0, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime + TimeSpan.FromDays(1)).Length);
+				Assert.Equal(1, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5)).Length);
+				Assert.Equal(1, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime).Length);
+				Assert.Equal(0, user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime - TimeSpan.FromDays(1)).Length);
 
 
-                var firstPayment = Money.Coins(0.04m);
+				var firstPayment = Money.Coins(0.04m);
 
-                var txFee = Money.Zero;
+				var txFee = Money.Zero;
 
-                var rate = user.BitPay.GetRates();
+				var rate = user.BitPay.GetRates();
 
-                var cashCow = tester.ExplorerNode;
-                var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
-                cashCow.SendToAddress(invoiceAddress, firstPayment);
+				var cashCow = tester.ExplorerNode;
 
-                Money secondPayment = Money.Zero;
+				var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
+				var iii = ctx.AddressInvoices.ToArray();
+				Assert.True(IsMapped(invoice, ctx));
+				cashCow.SendToAddress(invoiceAddress, firstPayment);
 
-                Eventually(() =>
-                {
-                    tester.SimulateCallback(invoiceAddress);
-                    var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
-                    Assert.Equal("new", localInvoice.Status);
-                    Assert.Equal(firstPayment, localInvoice.BtcPaid);
-                    txFee = localInvoice.BtcDue - invoice.BtcDue;
-                    Assert.Equal("paidPartial", localInvoice.ExceptionStatus);
-                    secondPayment = localInvoice.BtcDue;
-                });
+				var invoiceEntity = repo.GetInvoice(null, invoice.Id, true).GetAwaiter().GetResult();
+				Assert.Equal(1, invoiceEntity.HistoricalAddresses.Length);
+				Assert.Null(invoiceEntity.HistoricalAddresses[0].UnAssigned);
 
-                cashCow.SendToAddress(invoiceAddress, secondPayment);
+				Money secondPayment = Money.Zero;
 
-                Eventually(() =>
-                {
-                    tester.SimulateCallback(invoiceAddress);
-                    var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
-                    Assert.Equal("paid", localInvoice.Status);
-                    Assert.Equal(firstPayment + secondPayment, localInvoice.BtcPaid);
-                    Assert.Equal(Money.Zero, localInvoice.BtcDue);
-                    Assert.Equal(false, (bool)((JValue)localInvoice.ExceptionStatus).Value);
-                });
+				Eventually(() =>
+				{
+					tester.SimulateCallback(invoiceAddress);
+					var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
+					Assert.Equal("new", localInvoice.Status);
+					Assert.Equal(firstPayment, localInvoice.BtcPaid);
+					txFee = localInvoice.BtcDue - invoice.BtcDue;
+					Assert.Equal("paidPartial", localInvoice.ExceptionStatus);
+					Assert.NotEqual(localInvoice.BitcoinAddress, invoice.BitcoinAddress); //New address
+					Assert.True(IsMapped(invoice, ctx));
+					Assert.True(IsMapped(localInvoice, ctx));
 
-                cashCow.Generate(1); //The user has medium speed settings, so 1 conf is enough to be confirmed
+					invoiceEntity = repo.GetInvoice(null, invoice.Id, true).GetAwaiter().GetResult();
+					var historical1 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.Address == invoice.BitcoinAddress.ToString());
+					Assert.NotNull(historical1.UnAssigned);
+					var historical2 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.Address == localInvoice.BitcoinAddress.ToString());
+					Assert.Null(historical2.UnAssigned);
+					invoiceAddress = BitcoinAddress.Create(localInvoice.BitcoinAddress, cashCow.Network);
+					secondPayment = localInvoice.BtcDue;
+				});
 
-                Eventually(() =>
-                {
-                    tester.SimulateCallback();
-                    var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
-                    Assert.Equal("confirmed", localInvoice.Status);
-                });
+				cashCow.SendToAddress(invoiceAddress, secondPayment);
 
-                cashCow.Generate(5); //Now should be complete
+				Eventually(() =>
+				{
+					tester.SimulateCallback(invoiceAddress);
+					var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
+					Assert.Equal("paid", localInvoice.Status);
+					Assert.Equal(firstPayment + secondPayment, localInvoice.BtcPaid);
+					Assert.Equal(Money.Zero, localInvoice.BtcDue);
+					Assert.Equal(localInvoice.BitcoinAddress, invoiceAddress.ToString()); //no new address generated
+					Assert.True(IsMapped(localInvoice, ctx));
+					Assert.Equal(false, (bool)((JValue)localInvoice.ExceptionStatus).Value);
+				});
 
-                Eventually(() =>
-                {
-                    tester.SimulateCallback();
-                    var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
-                    Assert.Equal("complete", localInvoice.Status);
-                });
+				cashCow.Generate(1); //The user has medium speed settings, so 1 conf is enough to be confirmed
 
-                invoice = user.BitPay.CreateInvoice(new Invoice()
-                {
-                    Price = 5000.0,
-                    Currency = "USD",
-                    PosData = "posData",
-                    OrderId = "orderId",
-                    //RedirectURL = redirect + "redirect",
-                    //NotificationURL = CallbackUri + "/notification",
-                    ItemDesc = "Some description",
-                    FullNotifications = true
-                }, Facade.Merchant);
-                invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
+				Eventually(() =>
+				{
+					tester.SimulateCallback();
+					var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
+					Assert.Equal("confirmed", localInvoice.Status);
+				});
 
-                cashCow.SendToAddress(invoiceAddress, invoice.BtcDue + Money.Coins(1));
+				cashCow.Generate(5); //Now should be complete
 
-                Eventually(() =>
-                {
-                    tester.SimulateCallback(invoiceAddress);
-                    var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
-                    Assert.Equal("paid", localInvoice.Status);
-                    Assert.Equal(Money.Zero, localInvoice.BtcDue);
-                    Assert.Equal("paidOver", (string)((JValue)localInvoice.ExceptionStatus).Value);
-                });
+				Eventually(() =>
+				{
+					tester.SimulateCallback();
+					var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
+					Assert.Equal("complete", localInvoice.Status);
+				});
 
-                cashCow.Generate(1);
+				invoice = user.BitPay.CreateInvoice(new Invoice()
+				{
+					Price = 5000.0,
+					Currency = "USD",
+					PosData = "posData",
+					OrderId = "orderId",
+					//RedirectURL = redirect + "redirect",
+					//NotificationURL = CallbackUri + "/notification",
+					ItemDesc = "Some description",
+					FullNotifications = true
+				}, Facade.Merchant);
+				invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
 
-                Eventually(() =>
-                {
-                    tester.SimulateCallback();
-                    var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
-                    Assert.Equal("confirmed", localInvoice.Status);
-                    Assert.Equal(Money.Zero, localInvoice.BtcDue);
-                    Assert.Equal("paidOver", (string)((JValue)localInvoice.ExceptionStatus).Value);
-                });
-            }
-        }
+				cashCow.SendToAddress(invoiceAddress, invoice.BtcDue + Money.Coins(1));
 
-        private void Eventually(Action act)
+				Eventually(() =>
+				{
+					tester.SimulateCallback(invoiceAddress);
+					var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
+					Assert.Equal("paid", localInvoice.Status);
+					Assert.Equal(Money.Zero, localInvoice.BtcDue);
+					Assert.Equal("paidOver", (string)((JValue)localInvoice.ExceptionStatus).Value);
+				});
+
+				cashCow.Generate(1);
+
+				Eventually(() =>
+				{
+					tester.SimulateCallback();
+					var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
+					Assert.Equal("confirmed", localInvoice.Status);
+					Assert.Equal(Money.Zero, localInvoice.BtcDue);
+					Assert.Equal("paidOver", (string)((JValue)localInvoice.ExceptionStatus).Value);
+				});
+			}
+		}
+
+		private static bool IsMapped(Invoice invoice, ApplicationDbContext ctx)
+		{
+			var h = BitcoinAddress.Create(invoice.BitcoinAddress).ScriptPubKey.Hash.ToString();
+			return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.Address == h) != null;
+		}
+
+		private void Eventually(Action act)
         {
             CancellationTokenSource cts = new CancellationTokenSource(10000);
             while (true)

BTCPayServer/Controllers/InvoiceController.cs

@@ -113,7 +113,6 @@ namespace BTCPayServer.Controllers
 			entity.DepositAddress = await _Wallet.ReserveAddressAsync(ParseDerivationStrategy(derivationStrategy));
 
 			entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity);
-			await _Wallet.MapAsync(entity.DepositAddress.ScriptPubKey, entity.Id);
 			await _Watcher.WatchAsync(entity.Id);
 			var resp = entity.EntityToDTO();
 			return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };

BTCPayServer/Data/AddressInvoiceData.cs

@@ -21,5 +21,10 @@ namespace BTCPayServer.Data
 		{
 			get; set;
 		}
+
+		public DateTimeOffset? CreatedTime
+		{
+			get; set;
+		}
 	}
 }

BTCPayServer/Data/ApplicationDbContext.cs

@@ -26,6 +26,11 @@ namespace BTCPayServer.Data
 			get; set;
 		}
 
+		public DbSet<HistoricalAddressInvoiceData> HistoricalAddressInvoices
+		{
+			get; set;
+		}
+
 		public DbSet<PendingInvoiceData> PendingInvoices
 		{
 			get; set;
@@ -118,6 +123,13 @@ namespace BTCPayServer.Data
 				b.HasIndex(o => o.SIN);
 				b.HasIndex(o => o.StoreDataId);
 			});
+
+			builder.Entity<HistoricalAddressInvoiceData>()
+				.HasKey(o => new
+				{
+					o.InvoiceDataId,
+					o.Address
+				});
 		}
 	}
 }

BTCPayServer/Data/HistoricalAddressInvoiceData.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Data
+{
+    public class HistoricalAddressInvoiceData
+    {
+		public string InvoiceDataId
+		{
+			get; set;
+		}
+
+		public string Address
+		{
+			get; set;
+		}
+
+		public DateTimeOffset Assigned
+		{
+			get; set;
+		}
+
+		public DateTimeOffset? UnAssigned
+		{
+			get; set;
+		}
+	}
+}

BTCPayServer/Data/InvoiceData.cs

@@ -37,6 +37,11 @@ namespace BTCPayServer.Data
 			get; set;
 		}
 
+		public List<HistoricalAddressInvoiceData> HistoricalAddressInvoices
+		{
+			get; set;
+		}
+
 		public byte[] Blob
 		{
 			get; set;

BTCPayServer/Migrations/20171024163354_RenewUsedAddresses.Designer.cs

@@ -0,0 +1,477 @@
+// <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("20171024163354_RenewUsedAddresses")]
+    partial class RenewUsedAddresses
+    {
+        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<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/20171024163354_RenewUsedAddresses.cs

@@ -0,0 +1,47 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class RenewUsedAddresses : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "CreatedTime",
+                table: "AddressInvoices",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "HistoricalAddressInvoices",
+                columns: table => new
+                {
+                    InvoiceDataId = table.Column<string>(type: "TEXT", nullable: false),
+                    Address = table.Column<string>(type: "TEXT", nullable: false),
+                    Assigned = table.Column<DateTimeOffset>(nullable: false),
+                    UnAssigned = table.Column<DateTimeOffset>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_HistoricalAddressInvoices", x => new { x.InvoiceDataId, x.Address });
+                    table.ForeignKey(
+                        name: "FK_HistoricalAddressInvoices_Invoices_InvoiceDataId",
+                        column: x => x.InvoiceDataId,
+                        principalTable: "Invoices",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "HistoricalAddressInvoices");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedTime",
+                table: "AddressInvoices");
+        }
+    }
+}

BTCPayServer/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -25,6 +25,8 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("Address")
                         .ValueGeneratedOnAdd();
 
+                    b.Property<DateTimeOffset?>("CreatedTime");
+
                     b.Property<string>("InvoiceDataId");
 
                     b.HasKey("Address");
@@ -34,6 +36,21 @@ namespace BTCPayServer.Migrations
                     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")
@@ -367,6 +384,14 @@ namespace BTCPayServer.Migrations
                         .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")

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -8,6 +8,7 @@ using BTCPayServer.Models;
 using NBitpayClient;
 using Newtonsoft.Json.Linq;
 using NBitcoin.DataEncoders;
+using BTCPayServer.Data;
 
 namespace BTCPayServer.Services.Invoices
 {
@@ -253,6 +254,11 @@ namespace BTCPayServer.Services.Invoices
 			get;
 			set;
 		}
+		public HistoricalAddressInvoiceData[] HistoricalAddresses
+		{
+			get;
+			set;
+		}
 
 		public bool IsExpired()
 		{
@@ -273,7 +279,7 @@ namespace BTCPayServer.Services.Invoices
 				ExpirationTime = ExpirationTime,
 				BTCPrice = Money.Coins((decimal)(1.0 / Rate)).ToString(),
 				Status = Status,
-				Url = ServerUrl.WithTrailingSlash() +  "invoice?id=" + Id,
+				Url = ServerUrl.WithTrailingSlash() + "invoice?id=" + Id,
 				Currency = ProductInformation.Currency,
 				Flags = new Flags() { Refundable = Refundable }
 			};

BTCPayServer/Services/Invoices/InvoiceRepository.cs

@@ -54,8 +54,6 @@ namespace BTCPayServer.Services.Invoices
 			_ContextFactory = contextFactory;
 		}
 
-
-
 		public async Task AddPendingInvoice(string invoiceId)
 		{
 			using(var ctx = _ContextFactory.CreateContext())
@@ -79,6 +77,14 @@ namespace BTCPayServer.Services.Invoices
 			}
 		}
 
+		public async Task<string> GetInvoiceIdFromScriptPubKey(Script scriptPubKey)
+		{
+			using(var db = _ContextFactory.CreateContext())
+			{
+				var result = await db.AddressInvoices.FindAsync(scriptPubKey.Hash.ToString());
+				return result?.InvoiceDataId;
+			}
+		}
 
 		public async Task<string[]> GetPendingInvoices()
 		{
@@ -122,11 +128,26 @@ namespace BTCPayServer.Services.Invoices
 					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
+				});
 				await context.SaveChangesAsync().ConfigureAwait(false);
 			}
 
 			AddToTextSearch(invoice.Id,
 				invoice.Id,
+				invoice.DepositAddress.ToString(),
 				invoice.InvoiceTime.ToString(CultureInfo.InvariantCulture),
 				invoice.ProductInformation.Price.ToString(CultureInfo.InvariantCulture),
 				invoice.GetTotalCryptoDue().ToString(),
@@ -139,6 +160,63 @@ namespace BTCPayServer.Services.Invoices
 			return invoice;
 		}
 
+		public async Task<bool> NewAddress(string invoiceId, BitcoinAddress bitcoinAddress)
+		{
+			using(var context = _ContextFactory.CreateContext())
+			{
+				var invoice = await context.Invoices.FirstOrDefaultAsync(i => i.Id == invoiceId);
+				if(invoice == null)
+					return false;
+				var invoiceEntity = ToObject<InvoiceEntity>(invoice.Blob);
+				var old = invoiceEntity.DepositAddress;
+				invoiceEntity.DepositAddress = bitcoinAddress;
+				invoice.Blob = ToBytes(invoiceEntity);
+				if(old != null)
+				{
+					MarkUnassigned(invoiceId, old, context);
+				}
+				context.AddressInvoices.Add(new AddressInvoiceData() { Address = bitcoinAddress.ScriptPubKey.Hash.ToString(), InvoiceDataId = invoiceId, CreatedTime = DateTimeOffset.UtcNow });
+				context.HistoricalAddressInvoices.Add(new HistoricalAddressInvoiceData()
+				{
+					InvoiceDataId = invoiceId,
+					Address = bitcoinAddress.ToString(),
+					Assigned = DateTimeOffset.UtcNow
+				});
+
+				await context.SaveChangesAsync();
+				AddToTextSearch(invoice.Id, bitcoinAddress.ToString());
+				return true;
+			}
+		}
+
+		private static void MarkUnassigned(string invoiceId, BitcoinAddress old, ApplicationDbContext context)
+		{
+			var historical = new HistoricalAddressInvoiceData();
+			historical.InvoiceDataId = invoiceId;
+			historical.Address = old.ToString();
+			historical.UnAssigned = DateTimeOffset.UtcNow;
+			context.Attach(historical);
+			context.Entry(historical).Property(o => o.UnAssigned).IsModified = true;
+		}
+
+		public async Task UnaffectAddress(string invoiceId)
+		{
+			using(var context = _ContextFactory.CreateContext())
+			{
+				var invoiceData = await context.FindAsync<InvoiceData>(invoiceId).ConfigureAwait(false);
+				if(invoiceData == null)
+					return;
+				var invoiceEntity = ToObject<InvoiceEntity>(invoiceData.Blob);
+				if(invoiceEntity.DepositAddress == null)
+					return;
+				MarkUnassigned(invoiceId, invoiceEntity.DepositAddress, context);
+				try
+				{
+					await context.SaveChangesAsync();
+				}
+				catch(DbUpdateException) { } //Possibly, it was unassigned before
+			}
+		}
 
 		private string[] SearchInvoice(string searchTerms)
 		{
@@ -173,7 +251,7 @@ namespace BTCPayServer.Services.Invoices
 			}
 		}
 
-		public async Task<InvoiceEntity> GetInvoice(string storeId, string id)
+		public async Task<InvoiceEntity> GetInvoice(string storeId, string id, bool includeHistoricalAddresses = false)
 		{
 			using(var context = _ContextFactory.CreateContext())
 			{
@@ -181,8 +259,10 @@ namespace BTCPayServer.Services.Invoices
 					context
 					.Invoices
 					.Include(o => o.Payments)
-					.Include(o => o.RefundAddresses)
-					.Where(i => i.Id == id);
+					.Include(o => o.RefundAddresses);
+				if(includeHistoricalAddresses)
+					query = query.Include(o => o.HistoricalAddressInvoices);
+				query = query.Where(i => i.Id == id);
 
 				if(storeId != null)
 					query = query.Where(i => i.StoreDataId == storeId);
@@ -203,6 +283,10 @@ namespace BTCPayServer.Services.Invoices
 			entity.Status = invoice.Status;
 			entity.RefundMail = invoice.CustomerEmail;
 			entity.Refundable = invoice.RefundAddresses.Count != 0;
+			if(invoice.HistoricalAddressInvoices != null)
+			{
+				entity.HistoricalAddresses = invoice.HistoricalAddressInvoices.ToArray();
+			}
 			return entity;
 		}
 

BTCPayServer/Services/Invoices/InvoiceWatcher.cs

@@ -45,7 +45,7 @@ namespace BTCPayServer.Services.Invoices
 
 		public async Task NotifyReceived(Script scriptPubKey)
 		{
-			var invoice = await _Wallet.GetInvoiceId(scriptPubKey);
+			var invoice = await _InvoiceRepository.GetInvoiceIdFromScriptPubKey(scriptPubKey);
 			if(invoice != null)
 				_WatchRequests.Add(invoice);
 		}
@@ -81,7 +81,7 @@ namespace BTCPayServer.Services.Invoices
 					}
 
 					var expirationMonitoring = invoice.MonitoringExpiration.HasValue ? invoice.MonitoringExpiration.Value : invoice.InvoiceTime + TimeSpan.FromMinutes(60);
-					if(invoice.Status == "complete" || 
+					if(invoice.Status == "complete" ||
 					   ((invoice.Status == "invalid" || invoice.Status == "expired") && expirationMonitoring < DateTimeOffset.UtcNow))
 					{
 						if(await _InvoiceRepository.RemovePendingInvoice(invoice.Id).ConfigureAwait(false))
@@ -113,7 +113,7 @@ 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 => _Wallet.GetInvoiceId(u.Output.ScriptPubKey)).ToArray();
+			var invoiceIds = utxos.Select(u => _InvoiceRepository.GetInvoiceIdFromScriptPubKey(u.Output.ScriptPubKey)).ToArray();
 			utxos =
 				utxos
 				.Where((u, i) => invoiceIds[i].GetAwaiter().GetResult() == invoice.Id)
@@ -125,16 +125,23 @@ namespace BTCPayServer.Services.Invoices
 					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;
+				}
 			}
 			//////
 
 			if(invoice.Status == "new" && invoice.ExpirationTime < DateTimeOffset.UtcNow)
 			{
 				needSave = true;
+				await _InvoiceRepository.UnaffectAddress(invoice.Id);
 				invoice.Status = "expired";
 			}
 
@@ -151,6 +158,7 @@ namespace BTCPayServer.Services.Invoices
 							_NotificationManager.Notify(invoice);
 						}
 						invoice.ExceptionStatus = null;
+						await _InvoiceRepository.UnaffectAddress(invoice.Id);
 						needSave = true;
 					}
 					else if(invoice.Status == "expired")
@@ -163,13 +171,21 @@ namespace BTCPayServer.Services.Invoices
 				if(totalPaid > invoice.GetTotalCryptoDue() && invoice.ExceptionStatus != "paidOver")
 				{
 					invoice.ExceptionStatus = "paidOver";
+					await _InvoiceRepository.UnaffectAddress(invoice.Id);
 					needSave = true;
 				}
 
 				if(totalPaid < invoice.GetTotalCryptoDue() && invoice.Payments.Count != 0 && invoice.ExceptionStatus != "paidPartial")
 				{
+					Logs.PayServer.LogInformation("Paid to " + invoice.DepositAddress);
 					invoice.ExceptionStatus = "paidPartial";
 					needSave = true;
+					if(dirtyAddress)
+					{
+						var address = await _Wallet.ReserveAddressAsync(_DerivationFactory.Parse(invoice.DerivationStrategy));
+						Logs.PayServer.LogInformation("Generate new " + address);
+						await _InvoiceRepository.NewAddress(invoice.Id, address);
+					}
 				}
 			}
 
@@ -194,6 +210,7 @@ namespace BTCPayServer.Services.Invoices
 					var totalConfirmed = transactions.Select(t => t.Payment.Output.Value).Sum();
 					if(totalConfirmed >= invoice.GetTotalCryptoDue())
 					{
+						await _InvoiceRepository.UnaffectAddress(invoice.Id);
 						invoice.Status = "confirmed";
 						_NotificationManager.Notify(invoice);
 						needSave = true;
@@ -201,6 +218,7 @@ namespace BTCPayServer.Services.Invoices
 				}
 				else
 				{
+					await _InvoiceRepository.UnaffectAddress(invoice.Id);
 					invoice.Status = "invalid";
 					needSave = true;
 				}

BTCPayServer/Services/Wallets/BTCPayWallet.cs

@@ -39,28 +39,6 @@ namespace BTCPayServer.Services.Wallets
 			await _Client.TrackAsync(derivationStrategy);
 		}
 
-		public async Task<string> GetInvoiceId(Script scriptPubKey)
-		{
-			using(var db = _DBFactory.CreateContext())
-			{
-				var result = await db.AddressInvoices.FindAsync(scriptPubKey.Hash.ToString());
-				return result?.InvoiceDataId;
-			}
-		}
-
-		public async Task MapAsync(Script address, string invoiceId)
-		{
-			using(var db = _DBFactory.CreateContext())
-			{
-				db.AddressInvoices.Add(new AddressInvoiceData()
-				{
-					Address = address.Hash.ToString(),
-					InvoiceDataId = invoiceId
-				});
-				await db.SaveChangesAsync();
-			}
-		}
-
 		private byte[] ToBytes<T>(T obj)
 		{
 			return ZipUtils.Zip(_Serializer.ToString(obj));