bump

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -144,6 +144,7 @@ namespace BTCPayServer.Tests
             _Host.Start();
             InvoiceRepository = (InvoiceRepository)_Host.Services.GetService(typeof(InvoiceRepository));
             StoreRepository = (StoreRepository)_Host.Services.GetService(typeof(StoreRepository));
+            Networks = (BTCPayNetworkProvider)_Host.Services.GetService(typeof(BTCPayNetworkProvider));
             var dashBoard = (NBXplorerDashboard)_Host.Services.GetService(typeof(NBXplorerDashboard));
             while(!dashBoard.IsFullySynched())
             {
@@ -226,6 +227,7 @@ namespace BTCPayServer.Tests
         }
         public InvoiceRepository InvoiceRepository { get; private set; }
         public StoreRepository StoreRepository { get; private set; }
+        public BTCPayNetworkProvider Networks { get; private set; }
         public Uri IntegratedLightning { get; internal set; }
         public bool InContainer { get; internal set; }
 

BTCPayServer.Tests/StorageTests.cs

@@ -190,21 +190,8 @@ namespace BTCPayServer.Tests
         
         private async Task CanUploadRemoveFiles(ServerController controller)
         {
-            var filename = "uploadtestfile.txt";
             var fileContent = "content";
-            File.WriteAllText(filename, fileContent);
-
-            var fileInfo = new FileInfo(filename);
-            var formFile = new FormFile(
-                new FileStream(filename, FileMode.OpenOrCreate),
-                0,
-                fileInfo.Length, fileInfo.Name, fileInfo.Name)
-            {
-                Headers = new HeaderDictionary()
-            };
-            formFile.ContentType = "text/plain";
-            formFile.ContentDisposition = $"form-data; name=\"file\"; filename=\"{fileInfo.Name}\"";
-            var uploadFormFileResult = Assert.IsType<RedirectToActionResult>(await controller.CreateFile(formFile));
+            var uploadFormFileResult = Assert.IsType<RedirectToActionResult>(await controller.CreateFile(TestUtils.GetFormFile("uploadtestfile.txt", fileContent)));
             Assert.True(uploadFormFileResult.RouteValues.ContainsKey("fileId"));
             var fileId = uploadFormFileResult.RouteValues["fileId"].ToString();
             Assert.Equal("Files", uploadFormFileResult.ActionName);

BTCPayServer.Tests/TestUtils.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Internal;
+using Xunit.Sdk;
+
+namespace BTCPayServer.Tests
+{
+    public static class TestUtils
+    {
+        public static FormFile GetFormFile(string filename, string content)
+        {
+            File.WriteAllText(filename, content);
+
+            var fileInfo = new FileInfo(filename);
+            FormFile formFile = new FormFile(
+                new FileStream(filename, FileMode.OpenOrCreate),
+                0,
+                fileInfo.Length, fileInfo.Name, fileInfo.Name)
+            {
+                Headers = new HeaderDictionary()
+            };
+            formFile.ContentType = "text/plain";
+            formFile.ContentDisposition = $"form-data; name=\"file\"; filename=\"{fileInfo.Name}\"";
+            return formFile;
+        }
+        public static void Eventually(Action act)
+        {
+            CancellationTokenSource cts = new CancellationTokenSource(20000);
+            while (true)
+            {
+                try
+                {
+                    act();
+                    break;
+                }
+                catch (XunitException) when (!cts.Token.IsCancellationRequested)
+                {
+                    cts.Token.WaitHandle.WaitOne(500);
+                }
+            }
+        }
+
+        public static async Task EventuallyAsync(Func<Task> act)
+        {
+            CancellationTokenSource cts = new CancellationTokenSource(20000);
+            while (true)
+            {
+                try
+                {
+                    await act();
+                    break;
+                }
+                catch (XunitException) when (!cts.Token.IsCancellationRequested)
+                {
+                    await Task.Delay(500);
+                }
+            }
+        }
+    }
+}

BTCPayServer.Tests/UnitTest1.cs

@@ -58,6 +58,9 @@ using System.Runtime.CompilerServices;
 using System.Net;
 using BTCPayServer.Models.AccountViewModels;
 using BTCPayServer.Services.U2F.Models;
+using Microsoft.AspNetCore.Http.Internal;
+using Microsoft.AspNetCore.Http;
+using NBXplorer.DerivationStrategy;
 
 namespace BTCPayServer.Tests
 {
@@ -1457,59 +1460,70 @@ namespace BTCPayServer.Tests
         [Trait("Fast", "Fast")]
         public void CanParseDerivationScheme()
         {
-            var parser = new DerivationSchemeParser(Network.TestNet);
+            var  testnetNetworkProvider = new BTCPayNetworkProvider(NetworkType.Testnet);
+            var regtestNetworkProvider = new BTCPayNetworkProvider(NetworkType.Regtest);
+            var mainnetNetworkProvider = new BTCPayNetworkProvider(NetworkType.Mainnet);
+            var testnetParser = new DerivationSchemeParser(testnetNetworkProvider.GetNetwork("BTC"));
+            var mainnetParser = new DerivationSchemeParser(mainnetNetworkProvider.GetNetwork("BTC"));
             NBXplorer.DerivationStrategy.DerivationStrategyBase result;
             //  Passing electrum stuff
-            // Native
-            result = parser.Parse("zpub6nL6PUGurpU3DfPDSZaRS6WshpbNc9ctCFFzrCn54cssnheM31SZJZUcFHKtjJJNhAueMbh6ptFMfy1aeiMQJr3RJ4DDt1hAPx7sMTKV48t");
+            // Passing a native segwit from mainnet to a testnet parser, means the testnet parser will try to convert it into segwit
+            result = testnetParser.Parse("zpub6nL6PUGurpU3DfPDSZaRS6WshpbNc9ctCFFzrCn54cssnheM31SZJZUcFHKtjJJNhAueMbh6ptFMfy1aeiMQJr3RJ4DDt1hAPx7sMTKV48t");
             Assert.Equal("tpubD93CJNkmGjLXnsBqE2zGDqfEh1Q8iJ8wueordy3SeWt1RngbbuxXCsqASuVWFywmfoCwUE1rSfNJbaH4cBNcbp8WcyZgPiiRSTazLGL8U9w", result.ToString());
+            result = mainnetParser.Parse("zpub6nL6PUGurpU3DfPDSZaRS6WshpbNc9ctCFFzrCn54cssnheM31SZJZUcFHKtjJJNhAueMbh6ptFMfy1aeiMQJr3RJ4DDt1hAPx7sMTKV48t");
+            Assert.Equal("xpub68fZn8w5ZTP5X4zymr1B1vKsMtJUiudtN2DZHQzJJc87gW1tXh7S4SALCsQijUzXstg2reVyuZYFuPnTDKXNiNgDZNpNiC4BrVzaaGEaRHj", result.ToString());
             // P2SH
-            result = parser.Parse("ypub6QqdH2c5z79681jUgdxjGJzGW9zpL4ryPCuhtZE4GpvrJoZqM823XQN6iSQeVbbbp2uCRQ9UgpeMcwiyV6qjvxTWVcxDn2XEAnioMUwsrQ5");
+            result = testnetParser.Parse("upub57Wa4MvRPNyAipy1MCpERxcFpHR2ZatyikppkyeWkoRL6QJvLVMo39jYdcaJVxyvBURyRVmErBEA5oGicKBgk1j72GAXSPFH5tUDoGZ8nEu");
             Assert.Equal("tpubD6NzVbkrYhZ4YWjDJUACG9E8fJx2NqNY1iynTiPKEjJrzzRKAgha3nNnwGXr2BtvCJKJHW4nmG7rRqc2AGGy2AECgt16seMyV2FZivUmaJg-[p2sh]", result.ToString());
-            result = parser.Parse("xpub661MyMwAqRbcGeVGU5e5KBcau1HHEUGf9Wr7k4FyLa8yRPNQrrVa7Ndrgg8Afbe2UYXMSL6tJBFd2JewwWASsePPLjkcJFL1tTVEs3UQ23X");
-            Assert.Equal("tpubD6NzVbkrYhZ4YSg7vGdAX6wxE8NwDrmih9SR6cK7gUtsAg37w5LfFpJgviCxC6bGGT4G3uckqH5fiV9ZLN1gm5qgQLVuymzFUR5ed7U7ksu-[legacy]", result.ToString());
+
+            result = mainnetParser.Parse("ypub6QqdH2c5z79681jUgdxjGJzGW9zpL4ryPCuhtZE4GpvrJoZqM823XQN6iSQeVbbbp2uCRQ9UgpeMcwiyV6qjvxTWVcxDn2XEAnioMUwsrQ5");
+            Assert.Equal("xpub661MyMwAqRbcGiYMrHB74DtmLBrNPSsUU6PV7ALAtpYyFhkc6TrUuLhxhET4VgwgQPnPfvYvEAHojf7QmQRj8imudHFoC7hju4f9xxri8wR-[p2sh]", result.ToString());
+
+            // if prefix not recognize, assume it is segwit
+            result = testnetParser.Parse("xpub661MyMwAqRbcGeVGU5e5KBcau1HHEUGf9Wr7k4FyLa8yRPNQrrVa7Ndrgg8Afbe2UYXMSL6tJBFd2JewwWASsePPLjkcJFL1tTVEs3UQ23X");
+            Assert.Equal("tpubD6NzVbkrYhZ4YSg7vGdAX6wxE8NwDrmih9SR6cK7gUtsAg37w5LfFpJgviCxC6bGGT4G3uckqH5fiV9ZLN1gm5qgQLVuymzFUR5ed7U7ksu", result.ToString());
             ////////////////
 
             var tpub = "tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o";
 
-            result = parser.Parse(tpub);
+            result = testnetParser.Parse(tpub);
             Assert.Equal(tpub, result.ToString());
-            parser.HintScriptPubKey = BitcoinAddress.Create("tb1q4s33amqm8l7a07zdxcunqnn3gcsjcfz3xc573l", parser.Network).ScriptPubKey;
-            result = parser.Parse(tpub);
+            testnetParser.HintScriptPubKey = BitcoinAddress.Create("tb1q4s33amqm8l7a07zdxcunqnn3gcsjcfz3xc573l", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
             Assert.Equal(tpub, result.ToString());
 
-            parser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", parser.Network).ScriptPubKey;
-            result = parser.Parse(tpub);
+            testnetParser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
             Assert.Equal($"{tpub}-[p2sh]", result.ToString());
 
-            parser.HintScriptPubKey = BitcoinAddress.Create("mwD8bHS65cdgUf6rZUUSoVhi3wNQFu1Nfi", parser.Network).ScriptPubKey;
-            result = parser.Parse(tpub);
+            testnetParser.HintScriptPubKey = BitcoinAddress.Create("mwD8bHS65cdgUf6rZUUSoVhi3wNQFu1Nfi", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
             Assert.Equal($"{tpub}-[legacy]", result.ToString());
 
-            parser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", parser.Network).ScriptPubKey;
-            result = parser.Parse($"{tpub}-[legacy]");
+            testnetParser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse($"{tpub}-[legacy]");
             Assert.Equal($"{tpub}-[p2sh]", result.ToString());
 
-            result = parser.Parse(tpub);
+            result = testnetParser.Parse(tpub);
             Assert.Equal($"{tpub}-[p2sh]", result.ToString());
 
-            parser = new DerivationSchemeParser(Network.RegTest);
-            var parsed = parser.Parse("xpub6DG1rMYXiQtCc6CfdLFD9CtxqhzzRh7j6Sq6EdE9abgYy3cfDRrniLLv2AdwqHL1exiLnnKR5XXcaoiiexf3Y9R6J6rxkJtqJHzNzMW9QMZ-[p2sh]");
+            var regtestParser = new DerivationSchemeParser(regtestNetworkProvider.GetNetwork("BTC"));
+            var parsed = regtestParser.Parse("xpub6DG1rMYXiQtCc6CfdLFD9CtxqhzzRh7j6Sq6EdE9abgYy3cfDRrniLLv2AdwqHL1exiLnnKR5XXcaoiiexf3Y9R6J6rxkJtqJHzNzMW9QMZ-[p2sh]");
             Assert.Equal("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[p2sh]", parsed.ToString());
 
             // Let's make sure we can't generate segwit with dogecoin
-            parser = new DerivationSchemeParser(NBitcoin.Altcoins.Dogecoin.Instance.Regtest);
-            parsed = parser.Parse("xpub6DG1rMYXiQtCc6CfdLFD9CtxqhzzRh7j6Sq6EdE9abgYy3cfDRrniLLv2AdwqHL1exiLnnKR5XXcaoiiexf3Y9R6J6rxkJtqJHzNzMW9QMZ-[p2sh]");
+            regtestParser = new DerivationSchemeParser(regtestNetworkProvider.GetNetwork("DOGE"));
+            parsed = regtestParser.Parse("xpub6DG1rMYXiQtCc6CfdLFD9CtxqhzzRh7j6Sq6EdE9abgYy3cfDRrniLLv2AdwqHL1exiLnnKR5XXcaoiiexf3Y9R6J6rxkJtqJHzNzMW9QMZ-[p2sh]");
             Assert.Equal("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[legacy]", parsed.ToString());
 
-            parser = new DerivationSchemeParser(NBitcoin.Altcoins.Dogecoin.Instance.Regtest);
-            parsed = parser.Parse("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[p2sh]");
+            regtestParser = new DerivationSchemeParser(regtestNetworkProvider.GetNetwork("DOGE"));
+            parsed = regtestParser.Parse("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[p2sh]");
             Assert.Equal("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[legacy]", parsed.ToString());
         }
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public void CanDisablePaymentMethods()
+        public void CanAddDerivationSchemes()
         {
             using (var tester = ServerTester.Create())
             {
@@ -1519,7 +1533,7 @@ namespace BTCPayServer.Tests
                 user.RegisterDerivationScheme("BTC");
                 user.RegisterDerivationScheme("LTC");
                 user.RegisterLightningNode("BTC", LightningConnectionType.CLightning);
-
+                var btcNetwork = tester.PayTester.Networks.GetNetwork("BTC");
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 1.5m,
@@ -1540,16 +1554,18 @@ namespace BTCPayServer.Tests
                 lightningVM = (LightningNodeViewModel)Assert.IsType<ViewResult>(controller.AddLightningNode(user.StoreId, "BTC")).Model;
                 Assert.False(lightningVM.Enabled);
 
+                // Only Enabling/Disabling the payment method must redirect to store page
                 var derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
                 Assert.True(derivationVM.Enabled);
                 derivationVM.Enabled = false;
                 Assert.IsType<RedirectToActionResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult());
                 derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
-                // Confirmation
-                controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult();
                 Assert.False(derivationVM.Enabled);
+
+                // Clicking next without changing anything should send to the confirmation screen
                 derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
-                Assert.False(derivationVM.Enabled);
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult()).Model;
+                Assert.True(derivationVM.Confirmation);
 
                 invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
@@ -1563,6 +1579,78 @@ namespace BTCPayServer.Tests
 
                 Assert.Single(invoice.CryptoInfo);
                 Assert.Equal("LTC", invoice.CryptoInfo[0].CryptoCode);
+
+                // Removing the derivation scheme, should redirect to store page
+                var oldScheme = derivationVM.DerivationScheme;
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
+                derivationVM.DerivationScheme = null;
+                Assert.IsType<RedirectToActionResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult());
+
+                // Setting it again should redirect to the confirmation page
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
+                derivationVM.DerivationScheme = oldScheme;
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult()).Model;
+                Assert.True(derivationVM.Confirmation);
+
+                // Can we upload coldcard settings? (Should fail, we are giving a mainnet file to a testnet network)
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
+                string content = "{\"keystore\": {\"ckcc_xpub\": \"xpub661MyMwAqRbcGVBsTGeNZN6QGVHmMHLdSA4FteGsRrEriu4pnVZMZWnruFFFXkMnyoBjyHndD3Qwcfz4MPzBUxjSevweNFQx7SAYZATtcDw\", \"xpub\": \"ypub6WWc2gWwHbdnAAyJDnR4SPL1phRh7REqrPBfZeizaQ1EmTshieRXJC3Z5YoU4wkcdKHEjQGkh6AYEzCQC1Kz3DNaWSwdc1pc8416hAjzqyD\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/0'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}";
+                derivationVM.ColdcardPublicFile = TestUtils.GetFormFile("wallet.json", content);
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult()).Model;
+                Assert.False(derivationVM.Confirmation); // Should fail, we are giving a mainnet file to a testnet network 
+
+                // And with a good file? (upub)
+                content = "{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"upub5DBYp1qGgsTrkzCptMGZc2x18pquLwGrBw6nS59T4NViZ4cni1mGowQzziy85K8vzkp1jVtWrSkLhqk9KDfvrGeB369wGNYf39kX8rQfiLn\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/0'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}";
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
+                derivationVM.ColdcardPublicFile = TestUtils.GetFormFile("wallet2.json", content);
+                derivationVM.Enabled = true;
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult()).Model;
+                Assert.True(derivationVM.Confirmation);
+                Assert.IsType<RedirectToActionResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult());
+
+                // Now let's check that no data has been lost in the process
+                var store = tester.PayTester.StoreRepository.FindStore(user.StoreId).GetAwaiter().GetResult();
+                var onchainBTC = store.GetSupportedPaymentMethods(tester.PayTester.Networks).OfType<DerivationSchemeSettings>().First(o => o.PaymentId.IsBTCOnChain);
+                DerivationSchemeSettings.TryParseFromColdcard(content, onchainBTC.Network, out var expected);
+                Assert.Equal(expected.ToJson(), onchainBTC.ToJson());
+
+                // Let's check that the root hdkey and account key path are taken into account when making a PSBT
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 1.5m,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                tester.ExplorerNode.Generate(1);
+                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo.First(c => c.CryptoCode == "BTC").Address, tester.ExplorerNode.Network);
+                tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(1m));
+                TestUtils.Eventually(() =>
+                {
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal("paid", invoice.Status);
+                });
+                var wallet = tester.PayTester.GetController<WalletsController>();
+                var psbt = wallet.CreatePSBT(btcNetwork, onchainBTC, new WalletSendLedgerModel()
+                {
+                    Amount = 0.5m,
+                    Destination = new Key().PubKey.GetAddress(btcNetwork.NBitcoinNetwork).ToString(),
+                    FeeSatoshiPerByte = 1
+                }, default).GetAwaiter().GetResult();
+
+                Assert.NotNull(psbt);
+
+                var root = new Mnemonic("usage fever hen zero slide mammal silent heavy donate budget pulse say brain thank sausage brand craft about save attract muffin advance illegal cabbage").DeriveExtKey().AsHDKeyCache();
+                Assert.All(psbt.PSBT.Inputs, input =>
+                {
+                    var keyPath = input.HDKeyPaths.Single();
+                    Assert.StartsWith(onchainBTC.AccountKeyPath.ToString(), keyPath.Value.Item2.ToString());
+                    Assert.Equal(root.Derive(keyPath.Value.Item2).GetPublicKey(), keyPath.Key);
+                    Assert.Equal(keyPath.Value.Item1, onchainBTC.RootFingerprint.Value);
+                });
             }
         }
 
@@ -2574,6 +2662,34 @@ donation:
             Assert.Throws<InvalidOperationException>(() => fetch.GetRatesAsync(default).GetAwaiter().GetResult());
         }
 
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void ParseDerivationSchemeSettings()
+        {
+            var mainnet = new BTCPayNetworkProvider(NetworkType.Mainnet).GetNetwork("BTC");
+            var root = new Mnemonic("usage fever hen zero slide mammal silent heavy donate budget pulse say brain thank sausage brand craft about save attract muffin advance illegal cabbage").DeriveExtKey();
+            Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"xpub661MyMwAqRbcGVBsTGeNZN6QGVHmMHLdSA4FteGsRrEriu4pnVZMZWnruFFFXkMnyoBjyHndD3Qwcfz4MPzBUxjSevweNFQx7SAYZATtcDw\", \"xpub\": \"ypub6WWc2gWwHbdnAAyJDnR4SPL1phRh7REqrPBfZeizaQ1EmTshieRXJC3Z5YoU4wkcdKHEjQGkh6AYEzCQC1Kz3DNaWSwdc1pc8416hAjzqyD\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/0'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", mainnet, out var settings));
+            Assert.Equal(root.GetPublicKey().GetHDFingerPrint(), settings.RootFingerprint);
+            Assert.Equal("Coldcard Import 0x60d1af8b", settings.Label);
+            Assert.Equal("49'/0'/0'", settings.AccountKeyPath.ToString());
+            Assert.Equal("ypub6WWc2gWwHbdnAAyJDnR4SPL1phRh7REqrPBfZeizaQ1EmTshieRXJC3Z5YoU4wkcdKHEjQGkh6AYEzCQC1Kz3DNaWSwdc1pc8416hAjzqyD", settings.AccountOriginal);
+            Assert.Equal(root.Derive(new KeyPath("m/49'/0'/0'")).Neuter().PubKey.WitHash.ScriptPubKey.Hash.ScriptPubKey, settings.AccountDerivation.Derive(new KeyPath()).ScriptPubKey);
+
+            var testnet = new BTCPayNetworkProvider(NetworkType.Testnet).GetNetwork("BTC");
+
+            // Should be legacy
+            Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"tpubDDWYqT3P24znfsaGX7kZcQhNc5LAjnQiKQvUCHF2jS6dsgJBRtymopEU5uGpMaR5YChjuiExZG1X2aTbqXkp82KqH5qnqwWHp6EWis9ZvKr\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/44'/1'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", testnet, out settings));
+            Assert.True(settings.AccountDerivation is DirectDerivationStrategy s && !s.Segwit);
+
+            // Should be segwit p2sh
+            Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"upub5DSddA9NoRUyJrQ4p86nsCiTSY7kLHrSxx3joEJXjHd4HPARhdXUATuk585FdWPVC2GdjsMePHb6BMDmf7c6KG4K4RPX6LVqBLtDcWpQJmh\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/1'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", testnet, out settings));
+            Assert.True(settings.AccountDerivation is P2SHDerivationStrategy p && p.Inner is DirectDerivationStrategy s2 && s2.Segwit);
+
+            // Should be segwit
+            Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"vpub5YjYxTemJ39tFRnuAhwduyxG2tKGjoEpmvqVQRPqdYrqa6YGoeSzBtHXaJUYB19zDbXs3JjbEcVWERjQBPf9bEfUUMZNMv1QnMyHV8JPqyf\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/84'/1'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", testnet, out settings));
+            Assert.True(settings.AccountDerivation is DirectDerivationStrategy s3 && s3.Segwit);
+        }
+
         [Fact]
         [Trait("Fast", "Fast")]
         public void CheckParseStatusMessageModel()
@@ -2721,42 +2837,5 @@ donation:
             var h = BitcoinAddress.Create(invoice.BitcoinAddress, Network.RegTest).ScriptPubKey.Hash.ToString();
             return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.GetAddress() == h) != null;
         }
-
-        public static class TestUtils
-        {
-            public static void Eventually(Action act)
-            {
-                CancellationTokenSource cts = new CancellationTokenSource(20000);
-                while (true)
-                {
-                    try
-                    {
-                        act();
-                        break;
-                    }
-                    catch (XunitException) when (!cts.Token.IsCancellationRequested)
-                    {
-                        cts.Token.WaitHandle.WaitOne(500);
-                    }
-                }
-            }
-
-            public static async Task EventuallyAsync(Func<Task> act)
-            {
-                CancellationTokenSource cts = new CancellationTokenSource(20000);
-                while (true)
-                {
-                    try
-                    {
-                        await act();
-                        break;
-                    }
-                    catch (XunitException) when (!cts.Token.IsCancellationRequested)
-                    {
-                        await Task.Delay(500);
-                    }
-                }
-            }
-        }
     }
 }

BTCPayServer/BTCPayNetwork.cs

@@ -10,6 +10,12 @@ using NBXplorer;
 
 namespace BTCPayServer
 {
+    public enum DerivationType
+    {
+        Legacy,
+        SegwitP2SH,
+        Segwit
+    }
     public class BTCPayDefaultSettings
     {
         static BTCPayDefaultSettings()
@@ -64,7 +70,8 @@ namespace BTCPayServer
         public KeyPath CoinType { get; internal set; }
         public int MaxTrackedConfirmation { get; internal set; } = 6;
         public string[] DefaultRateRules { get; internal set; } = Array.Empty<string>();
-
+        public bool SupportRBF { get; internal set; }
+        public Dictionary<uint, DerivationType> ElectrumMapping = new Dictionary<uint, DerivationType>();
         public override string ToString()
         {
             return CryptoCode;

BTCPayServer/BTCPayNetworkProvider.Bitcoin.cs

@@ -25,7 +25,22 @@ namespace BTCPayServer
                 CryptoImagePath = "imlegacy/bitcoin.svg",
                 LightningImagePath = "imlegacy/bitcoin-lightning.svg",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("0'") : new KeyPath("1'")
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("0'") : new KeyPath("1'"),
+                SupportRBF = true,
+                //https://github.com/spesmilo/electrum/blob/11733d6bc271646a00b69ff07657119598874da4/electrum/constants.py
+                ElectrumMapping = NetworkType == NetworkType.Mainnet
+                    ? new Dictionary<uint, DerivationType>()
+                    {
+                        {0x0488b21eU, DerivationType.Legacy }, // xpub
+                        {0x049d7cb2U, DerivationType.SegwitP2SH }, // ypub
+                        {0x4b24746U, DerivationType.Segwit }, //zpub
+                    }
+                    : new Dictionary<uint, DerivationType>()
+                    {
+                        {0x043587cfU, DerivationType.Legacy},
+                        {0x044a5262U, DerivationType.SegwitP2SH},
+                        {0x045f1cf6U, DerivationType.Segwit}
+                    }
             });
         }
     }

BTCPayServer/BTCPayNetworkProvider.Groestlcoin.cs

@@ -10,20 +10,21 @@ namespace BTCPayServer
     {
         public void InitGroestlcoin()
         {
-
             var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("GRS");
             Add(new BTCPayNetwork()
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
                 DisplayName = "Groestlcoin",
-                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://chainz.cryptoid.info/grs/tx.dws?{0}.htm" : "https://chainz.cryptoid.info/grs-test/tx.dws?{0}.htm",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet
+                    ? "https://chainz.cryptoid.info/grs/tx.dws?{0}.htm"
+                    : "https://chainz.cryptoid.info/grs-test/tx.dws?{0}.htm",
                 NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
                 NBXplorerNetwork = nbxplorerNetwork,
                 UriScheme = "groestlcoin",
                 DefaultRateRules = new[]
                 {
-                                "GRS_X = GRS_BTC * BTC_X",
-                                "GRS_BTC = bittrex(GRS_BTC)"
+                    "GRS_X = GRS_BTC * BTC_X",
+                    "GRS_BTC = bittrex(GRS_BTC)"
                 },
                 CryptoImagePath = "imlegacy/groestlcoin.png",
                 LightningImagePath = "imlegacy/groestlcoin-lightning.svg",

BTCPayServer/BTCPayNetworkProvider.Litecoin.cs

@@ -17,14 +17,30 @@ namespace BTCPayServer
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
                 DisplayName = "Litecoin",
-                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://live.blockcypher.com/ltc/tx/{0}/" : "http://explorer.litecointools.com/tx/{0}",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet
+                    ? "https://live.blockcypher.com/ltc/tx/{0}/"
+                    : "http://explorer.litecointools.com/tx/{0}",
                 NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
                 NBXplorerNetwork = nbxplorerNetwork,
                 UriScheme = "litecoin",
                 CryptoImagePath = "imlegacy/litecoin.svg",
                 LightningImagePath = "imlegacy/litecoin-lightning.svg",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("2'") : new KeyPath("1'")
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("2'") : new KeyPath("1'"),
+                //https://github.com/pooler/electrum-ltc/blob/0d6989a9d2fb2edbea421c116e49d1015c7c5a91/electrum_ltc/constants.py
+                ElectrumMapping = NetworkType == NetworkType.Mainnet
+                    ? new Dictionary<uint, DerivationType>()
+                    {
+                        {0x0488b21eU, DerivationType.Legacy },
+                        {0x049d7cb2U, DerivationType.SegwitP2SH },
+                        {0x04b24746U, DerivationType.Segwit },
+                    }
+                    : new Dictionary<uint, DerivationType>()
+                    {
+                        {0x043587cfU, DerivationType.Legacy },
+                        {0x044a5262U, DerivationType.SegwitP2SH },
+                        {0x045f1cf6U, DerivationType.Segwit }
+                    }
             });
         }
     }

BTCPayServer/BTCPayNetworkProvider.cs

@@ -56,6 +56,22 @@ namespace BTCPayServer
             InitGroestlcoin();
             InitViacoin();
 
+            // Assume that electrum mappings are same as BTC if not specified
+            foreach (var network in _Networks)
+            {
+                if(network.Value.ElectrumMapping.Count == 0)
+                {
+                    network.Value.ElectrumMapping = GetNetwork("BTC").ElectrumMapping;
+                    if (!network.Value.NBitcoinNetwork.Consensus.SupportSegwit)
+                    {
+                        network.Value.ElectrumMapping =
+                            network.Value.ElectrumMapping
+                            .Where(kv => kv.Value == DerivationType.Legacy)
+                            .ToDictionary(k => k.Key, k => k.Value);
+                    }
+                }
+            }
+
             // Disabled because of https://twitter.com/Cryptopia_NZ/status/1085084168852291586
             //InitPolis();
             //InitBitcoinplus();

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.1</TargetFramework>
-		<Version>1.0.3.96</Version>
+		<Version>1.0.3.98</Version>
     <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </PropertyGroup>
   <PropertyGroup>
@@ -47,10 +47,11 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="NBitcoin" Version="4.1.2.14" />
+    <PackageReference Include="NBitcoin" Version="4.1.2.15" />
     <PackageReference Include="NBitpayClient" Version="1.0.0.34" />	  
     <PackageReference Include="DBriize" Version="1.0.0.4" />
     <PackageReference Include="NBXplorer.Client" Version="2.0.0.11" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.3" />
     <PackageReference Include="NicolasDorier.RateLimits" Version="1.0.0.3" />
@@ -74,7 +75,7 @@
     <PackageReference Include="TwentyTwenty.Storage.Azure" Version="2.10.1" />
     <PackageReference Include="TwentyTwenty.Storage.Google" Version="2.10.1" />
     <PackageReference Include="TwentyTwenty.Storage.Local" Version="2.10.1" />
-    <PackageReference Include="U2F.Core" Version="2.0.1" />
+    <PackageReference Include="U2F.Core" Version="1.0.4" />
 		<PackageReference Include="YamlDotNet" Version="5.2.1" />
 	</ItemGroup>
 

BTCPayServer/Controllers/ManageController.U2F.cs

@@ -58,30 +58,32 @@ namespace BTCPayServer.Controllers
         [HttpPost]
         public async Task<IActionResult> AddU2FDevice(AddU2FDeviceViewModel viewModel)
         {
+            var errorMessage = string.Empty;
             try
             {
                 if (await _u2FService.CompleteRegistration(_userManager.GetUserId(User), viewModel.DeviceResponse,
                     string.IsNullOrEmpty(viewModel.Name) ? "Unlabelled U2F Device" : viewModel.Name))
                 {
                     return RedirectToAction("U2FAuthentication", new
+                        
                     {
                         StatusMessage = "Device added!"
                     });
                 }
-
-                throw new Exception("Could not add device.");
             }
             catch (Exception e)
             {
-                return RedirectToAction("U2FAuthentication", new
-                {
-                    StatusMessage = new StatusMessageModel()
-                    {
-                        Severity = StatusMessageModel.StatusSeverity.Error,
-                        Message = e.Message
-                    }
-                });
+                errorMessage = e.Message;
             }
+
+            return RedirectToAction("U2FAuthentication", new
+            {
+                StatusMessage = new StatusMessageModel()
+                {
+                    Severity = StatusMessageModel.StatusSeverity.Error,
+                    Message = string.IsNullOrEmpty(errorMessage) ? "Could not add device." : errorMessage
+                }
+            });
         }
     }
 }

BTCPayServer/Controllers/StoresController.BTCLike.cs

@@ -1,16 +1,19 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
+using BTCPayServer.Models;
 using BTCPayServer.Models.StoreViewModels;
 using BTCPayServer.Payments;
 using BTCPayServer.Services;
 using LedgerWallet;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using NBitcoin;
 using NBXplorer.DerivationStrategy;
@@ -99,22 +102,30 @@ namespace BTCPayServer.Controllers
 
         private void SetExistingValues(StoreData store, DerivationSchemeViewModel vm)
         {
-            vm.DerivationScheme = GetExistingDerivationStrategy(vm.CryptoCode, store)?.DerivationStrategyBase.ToString();
+            var derivation = GetExistingDerivationStrategy(vm.CryptoCode, store);
+            if (derivation != null)
+            {
+                vm.DerivationScheme = derivation.AccountDerivation.ToString();
+                vm.Config = derivation.ToJson();
+            }
             vm.Enabled = !store.GetStoreBlob().IsExcluded(new PaymentMethodId(vm.CryptoCode, PaymentTypes.BTCLike));
         }
 
-        private DerivationStrategy GetExistingDerivationStrategy(string cryptoCode, StoreData store)
+        private DerivationSchemeSettings GetExistingDerivationStrategy(string cryptoCode, StoreData store)
         {
             var id = new PaymentMethodId(cryptoCode, PaymentTypes.BTCLike);
             var existing = store.GetSupportedPaymentMethods(_NetworkProvider)
-                .OfType<DerivationStrategy>()
+                .OfType<DerivationSchemeSettings>()
                 .FirstOrDefault(d => d.PaymentId == id);
             return existing;
         }
+        
+        
 
         [HttpPost]
         [Route("{storeId}/derivations/{cryptoCode}")]
-        public async Task<IActionResult> AddDerivationScheme(string storeId, DerivationSchemeViewModel vm, string cryptoCode)
+        public async Task<IActionResult> AddDerivationScheme(string storeId, DerivationSchemeViewModel vm,
+            string cryptoCode)
         {
             vm.CryptoCode = cryptoCode;
             var store = HttpContext.GetStoreData();
@@ -126,45 +137,89 @@ namespace BTCPayServer.Controllers
             {
                 return NotFound();
             }
+
             vm.RootKeyPath = network.GetRootKeyPath();
+            DerivationSchemeSettings strategy = null;
+            
             var wallet = _WalletProvider.GetWallet(network);
             if (wallet == null)
             {
                 return NotFound();
             }
 
-            PaymentMethodId paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
-            var exisingStrategy = store.GetSupportedPaymentMethods(_NetworkProvider)
-                                       .Where(c => c.PaymentId == paymentMethodId)
-                                       .OfType<DerivationStrategy>()
-                                       .Select(c => c.DerivationStrategyBase.ToString())
-                                       .FirstOrDefault();
-            DerivationStrategy strategy = null;
-            try
+            if (!string.IsNullOrEmpty(vm.Config))
             {
-                if (!string.IsNullOrEmpty(vm.DerivationScheme))
+                if (!DerivationSchemeSettings.TryParseFromJson(vm.Config, network, out strategy))
                 {
-                    strategy = ParseDerivationStrategy(vm.DerivationScheme, null, network);
-                    vm.DerivationScheme = strategy.ToString();
+                    vm.StatusMessage = new StatusMessageModel()
+                    {
+                        Severity = StatusMessageModel.StatusSeverity.Error,
+                        Message = "Config file was not in the correct format"
+                    }.ToString();
+                    vm.Confirmation = false;
+                    return View(vm);
                 }
             }
-            catch
+
+            if (vm.ColdcardPublicFile != null)
             {
-                ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
-                vm.Confirmation = false;
-                return View(vm);
+                if (!DerivationSchemeSettings.TryParseFromColdcard(await ReadAllText(vm.ColdcardPublicFile), network, out strategy))
+                {
+                    vm.StatusMessage = new StatusMessageModel()
+                    {
+                        Severity = StatusMessageModel.StatusSeverity.Error,
+                        Message = "Coldcard public file was not in the correct format"
+                    }.ToString();
+                    vm.Confirmation = false;
+                    return View(vm);
+                }
             }
+            else
+            {
+                try
+                {
+                    if (!string.IsNullOrEmpty(vm.DerivationScheme))
+                    {
+                        var newStrategy = ParseDerivationStrategy(vm.DerivationScheme, null, network);
+                        if (newStrategy.AccountDerivation != strategy?.AccountDerivation)
+                        {
+                            strategy = newStrategy;
+                            strategy.AccountKeyPath = vm.KeyPath == null ? null : KeyPath.Parse(vm.KeyPath);
+                            vm.DerivationScheme = strategy.AccountDerivation.ToString();
+                        }
+                    }
+                    else
+                    {
+                        strategy = null;
+                    }
+                }
+                catch
+                {
+                    ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
+                    vm.Confirmation = false;
+                    return View(vm);
+                }
+            }
+
+            var oldConfig = vm.Config;
+            vm.Config = strategy == null ? null : strategy.ToJson();
+
+            PaymentMethodId paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
+            var exisingStrategy = store.GetSupportedPaymentMethods(_NetworkProvider)
+                .Where(c => c.PaymentId == paymentMethodId)
+                .OfType<DerivationSchemeSettings>()
+                .FirstOrDefault();
             var storeBlob = store.GetStoreBlob();
             var wasExcluded = storeBlob.GetExcludedPaymentMethods().Match(paymentMethodId);
             var willBeExcluded = !vm.Enabled;
 
             var showAddress = // Show addresses if:
-                              // - If the user is testing the hint address in confirmation screen
-                              (vm.Confirmation && !string.IsNullOrWhiteSpace(vm.HintAddress)) ||
-                              // - The user is setting a new derivation scheme
-                              (!vm.Confirmation && strategy != null && exisingStrategy != strategy.DerivationStrategyBase.ToString()) ||
-                              // - The user is clicking on continue without changing anything   
-                              (!vm.Confirmation && willBeExcluded == wasExcluded);
+                // - If the user is testing the hint address in confirmation screen
+                (vm.Confirmation && !string.IsNullOrWhiteSpace(vm.HintAddress)) ||
+                // - The user is clicking on continue after changing the config
+                (!vm.Confirmation && oldConfig != vm.Config) ||
+                // - The user is clickingon continue without changing config nor enabling/disabling
+                (!vm.Confirmation && oldConfig == vm.Config && willBeExcluded == wasExcluded);
 
             showAddress = showAddress && strategy != null;
             if (!showAddress)
@@ -172,10 +227,9 @@ namespace BTCPayServer.Controllers
                 try
                 {
                     if (strategy != null)
-                        await wallet.TrackAsync(strategy.DerivationStrategyBase);
+                        await wallet.TrackAsync(strategy.AccountDerivation);
                     store.SetSupportedPaymentMethod(paymentMethodId, strategy);
-                    storeBlob.SetExcluded(paymentMethodId, willBeExcluded);                    
-                    storeBlob.SetWalletKeyPathRoot(paymentMethodId, vm.KeyPath == null ? null : KeyPath.Parse(vm.KeyPath));
+                    storeBlob.SetExcluded(paymentMethodId, willBeExcluded);
                     store.SetStoreBlob(storeBlob);
                 }
                 catch
@@ -185,8 +239,14 @@ namespace BTCPayServer.Controllers
                 }
 
                 await _Repo.UpdateStore(store);
-                StatusMessage = $"Derivation scheme for {network.CryptoCode} has been modified.";
-                return RedirectToAction(nameof(UpdateStore), new { storeId = storeId });
+                if (oldConfig != vm.Config)
+                    StatusMessage = $"Derivation settings for {network.CryptoCode} has been modified.";
+                if (willBeExcluded != wasExcluded)
+                {
+                    var label = willBeExcluded ? "disabled" : "enabled";
+                    StatusMessage = $"On-Chain payments for {network.CryptoCode} has been {label}.";
+                }
+                return RedirectToAction(nameof(UpdateStore), new {storeId = storeId});
             }
             else if (!string.IsNullOrEmpty(vm.HintAddress))
             {
@@ -203,27 +263,43 @@ namespace BTCPayServer.Controllers
 
                 try
                 {
-                    strategy = ParseDerivationStrategy(vm.DerivationScheme, address.ScriptPubKey, network);
+                    var newStrategy = ParseDerivationStrategy(vm.DerivationScheme, address.ScriptPubKey, network);
+                    if (newStrategy.AccountDerivation != strategy.AccountDerivation)
+                    {
+                        strategy.AccountDerivation = newStrategy.AccountDerivation;
+                        strategy.AccountOriginal = null;
+                    }
                 }
                 catch
                 {
                     ModelState.AddModelError(nameof(vm.HintAddress), "Impossible to find a match with this address");
                     return ShowAddresses(vm, strategy);
                 }
+
                 vm.HintAddress = "";
-                vm.StatusMessage = "Address successfully found, please verify that the rest is correct and click on \"Confirm\"";
+                vm.StatusMessage =
+                    "Address successfully found, please verify that the rest is correct and click on \"Confirm\"";
                 ModelState.Remove(nameof(vm.HintAddress));
                 ModelState.Remove(nameof(vm.DerivationScheme));
             }
+
             return ShowAddresses(vm, strategy);
         }
 
-        private IActionResult ShowAddresses(DerivationSchemeViewModel vm, DerivationStrategy strategy)
+        private async Task<string> ReadAllText(IFormFile file)
         {
-            vm.DerivationScheme = strategy.DerivationStrategyBase.ToString();
+            using (var stream = new StreamReader(file.OpenReadStream()))
+            {
+                return await stream.ReadToEndAsync();
+            }
+        }
+
+        private IActionResult ShowAddresses(DerivationSchemeViewModel vm, DerivationSchemeSettings strategy)
+        {
+            vm.DerivationScheme = strategy.AccountDerivation.ToString();
             if (!string.IsNullOrEmpty(vm.DerivationScheme))
             {
-                var line = strategy.DerivationStrategyBase.GetLineFor(DerivationFeature.Deposit);
+                var line = strategy.AccountDerivation.GetLineFor(DerivationFeature.Deposit);
 
                 for (int i = 0; i < 10; i++)
                 {

BTCPayServer/Controllers/StoresController.cs

@@ -470,7 +470,7 @@ namespace BTCPayServer.Controllers
             var derivationByCryptoCode =
                 store
                 .GetSupportedPaymentMethods(_NetworkProvider)
-                .OfType<DerivationStrategy>()
+                .OfType<DerivationSchemeSettings>()
                 .ToDictionary(c => c.Network.CryptoCode);
             foreach (var network in _NetworkProvider.GetAll())
             {
@@ -478,7 +478,7 @@ namespace BTCPayServer.Controllers
                 vm.DerivationSchemes.Add(new StoreViewModel.DerivationScheme()
                 {
                     Crypto = network.CryptoCode,
-                    Value = strategy?.DerivationStrategyBase?.ToString() ?? string.Empty,
+                    Value = strategy?.ToPrettyString() ?? string.Empty,
                     WalletId = new WalletId(store.Id, network.CryptoCode),
                     Enabled = !excludeFilters.Match(new Payments.PaymentMethodId(network.CryptoCode, Payments.PaymentTypes.BTCLike))
                 });
@@ -596,11 +596,11 @@ namespace BTCPayServer.Controllers
                     .ToArray();
         }
 
-        private DerivationStrategy ParseDerivationStrategy(string derivationScheme, Script hint, BTCPayNetwork network)
+        private DerivationSchemeSettings ParseDerivationStrategy(string derivationScheme, Script hint, BTCPayNetwork network)
         {
-            var parser = new DerivationSchemeParser(network.NBitcoinNetwork);
+            var parser = new DerivationSchemeParser(network);
             parser.HintScriptPubKey = hint;
-            return new DerivationStrategy(parser.Parse(derivationScheme), network);
+            return new DerivationSchemeSettings(parser.Parse(derivationScheme), network);
         }
 
         [HttpGet]

BTCPayServer/Controllers/WalletsController.cs

@@ -80,9 +80,9 @@ namespace BTCPayServer.Controllers
 
             var onChainWallets = stores
                                 .SelectMany(s => s.GetSupportedPaymentMethods(NetworkProvider)
-                                              .OfType<DerivationStrategy>()
+                                              .OfType<DerivationSchemeSettings>()
                                               .Select(d => ((Wallet: _walletProvider.GetWallet(d.Network),
-                                                            DerivationStrategy: d.DerivationStrategyBase,
+                                                            DerivationStrategy: d.AccountDerivation,
                                                             Network: d.Network)))
                                               .Where(_ => _.Wallet != null)
                                               .Select(_ => (Wallet: _.Wallet,
@@ -118,12 +118,12 @@ namespace BTCPayServer.Controllers
             WalletId walletId)
         {
             var store = await Repository.FindStore(walletId.StoreId, GetUserId());
-            DerivationStrategy paymentMethod = GetPaymentMethod(walletId, store);
+            DerivationSchemeSettings paymentMethod = GetPaymentMethod(walletId, store);
             if (paymentMethod == null)
                 return NotFound();
 
             var wallet = _walletProvider.GetWallet(paymentMethod.Network);
-            var transactions = await wallet.FetchTransactions(paymentMethod.DerivationStrategyBase);
+            var transactions = await wallet.FetchTransactions(paymentMethod.AccountDerivation);
 
             var model = new ListTransactionsViewModel();
             foreach (var tx in transactions.UnconfirmedTransactions.Transactions.Concat(transactions.ConfirmedTransactions.Transactions))
@@ -151,7 +151,7 @@ namespace BTCPayServer.Controllers
             if (walletId?.StoreId == null)
                 return NotFound();
             var store = await Repository.FindStore(walletId.StoreId, GetUserId());
-            DerivationStrategy paymentMethod = GetPaymentMethod(walletId, store);
+            DerivationSchemeSettings paymentMethod = GetPaymentMethod(walletId, store);
             if (paymentMethod == null)
                 return NotFound();
             var network = this.NetworkProvider.GetNetwork(walletId?.CryptoCode);
@@ -171,11 +171,11 @@ namespace BTCPayServer.Controllers
 
             var feeProvider = _feeRateProvider.CreateFeeProvider(network);
             var recommendedFees = feeProvider.GetFeeRateAsync();
-            var balance = _walletProvider.GetWallet(network).GetBalance(paymentMethod.DerivationStrategyBase);
+            var balance = _walletProvider.GetWallet(network).GetBalance(paymentMethod.AccountDerivation);
             model.CurrentBalance = (await balance).ToDecimal(MoneyUnit.BTC);
             model.RecommendedSatoshiPerByte = (int)(await recommendedFees).GetFee(1).Satoshi;
             model.FeeSatoshiPerByte = model.RecommendedSatoshiPerByte;
-
+            model.SupportRBF = network.SupportRBF;
             using (CancellationTokenSource cts = new CancellationTokenSource())
             {
                 try
@@ -212,7 +212,7 @@ namespace BTCPayServer.Controllers
             var network = this.NetworkProvider.GetNetwork(walletId?.CryptoCode);
             if (network == null)
                 return NotFound();
-
+            vm.SupportRBF = network.SupportRBF;
             var destination = ParseDestination(vm.Destination, network.NBitcoinNetwork);
             if (destination == null)
                 ModelState.AddModelError(nameof(vm.Destination), "Invalid address");
@@ -233,7 +233,8 @@ namespace BTCPayServer.Controllers
                 Amount = vm.Amount.Value,
                 SubstractFees = vm.SubstractFees,
                 FeeSatoshiPerByte = vm.FeeSatoshiPerByte,
-                NoChange = vm.NoChange
+                NoChange = vm.NoChange,
+                DisableRBF = vm.DisableRBF
             };
             if (command == "ledger")
             {
@@ -242,18 +243,35 @@ namespace BTCPayServer.Controllers
             else
             {
                 var storeData = (await Repository.FindStore(walletId.StoreId, GetUserId()));
-                var derivationScheme = GetPaymentMethod(walletId, storeData).DerivationStrategyBase;
-                var psbt = await CreatePSBT(network, derivationScheme, sendModel, cancellation);
-                return File(psbt.PSBT.ToBytes(), "application/octet-stream", $"Send-{vm.Amount.Value}-{network.CryptoCode}-to-{destination[0].ToString()}.psbt");
+                var derivationScheme = GetPaymentMethod(walletId, storeData);
+                try
+                {
+                    var psbt = await CreatePSBT(network, derivationScheme, sendModel, cancellation);
+                    return File(psbt.PSBT.ToBytes(), "application/octet-stream", $"Send-{vm.Amount.Value}-{network.CryptoCode}-to-{destination[0].ToString()}.psbt");
+                }
+                catch (NBXplorerException ex)
+                {
+                    ModelState.AddModelError(nameof(vm.Amount), ex.Error.Message);
+                    return View(vm);
+                }
+                catch (NotSupportedException)
+                {
+                    ModelState.AddModelError(nameof(vm.Destination), "You need to update your version of NBXplorer");
+                    return View(vm);
+                }
             }
         }
 
-        private async Task<CreatePSBTResponse> CreatePSBT(BTCPayNetwork network, DerivationStrategyBase derivationScheme, WalletSendLedgerModel sendModel, CancellationToken cancellationToken)
+        public async Task<CreatePSBTResponse> CreatePSBT(BTCPayNetwork network, DerivationSchemeSettings derivationSettings, WalletSendLedgerModel sendModel, CancellationToken cancellationToken)
         {
             var nbx = ExplorerClientProvider.GetExplorerClient(network);
             CreatePSBTRequest psbtRequest = new CreatePSBTRequest();
             CreatePSBTDestination psbtDestination = new CreatePSBTDestination();
             psbtRequest.Destinations.Add(psbtDestination);
+            if (network.SupportRBF)
+            {
+                psbtRequest.RBF = !sendModel.DisableRBF;
+            }
             psbtDestination.Destination = BitcoinAddress.Create(sendModel.Destination, network.NBitcoinNetwork);
             psbtDestination.Amount = Money.Coins(sendModel.Amount);
             psbtRequest.FeePreference = new FeePreference();
@@ -264,7 +282,7 @@ namespace BTCPayServer.Controllers
             }
             psbtDestination.SubstractFees = sendModel.SubstractFees;
 
-            var psbt = (await nbx.CreatePSBTAsync(derivationScheme, psbtRequest, cancellationToken));
+            var psbt = (await nbx.CreatePSBTAsync(derivationSettings.AccountDerivation, psbtRequest, cancellationToken));
             if (psbt == null)
                 throw new NotSupportedException("You need to update your version of NBXplorer");
 
@@ -274,10 +292,27 @@ namespace BTCPayServer.Controllers
                 if (fee < network.MinFee)
                 {
                     psbtRequest.FeePreference = new FeePreference() { ExplicitFee = network.MinFee };
-                    psbt = (await nbx.CreatePSBTAsync(derivationScheme, psbtRequest, cancellationToken));
+                    psbt = (await nbx.CreatePSBTAsync(derivationSettings.AccountDerivation, psbtRequest, cancellationToken));
                 }
             }
 
+            if (derivationSettings.AccountKeyPath != null && derivationSettings.AccountKeyPath.Indexes.Length != 0)
+            {
+                // NBX only know the path relative to the account xpub.
+                // Here we rebase the hd_keys in the PSBT to have a keypath relative to the root HD so the wallet can sign
+                // Note that the fingerprint of the hd keys are now 0, which is wrong
+                // However, hardware wallets does not give a damn, and sometimes does not even allow us to get this fingerprint anyway.
+                foreach (var o in psbt.PSBT.Inputs.OfType<PSBTCoin>().Concat(psbt.PSBT.Outputs))
+                {
+                    var rootFP = derivationSettings.RootFingerprint is HDFingerprint fp ? fp : default;
+                    foreach (var keypath in o.HDKeyPaths.ToList())
+                    {
+                        var newKeyPath = derivationSettings.AccountKeyPath.Derive(keypath.Value.Item2);
+                        o.HDKeyPaths.Remove(keypath.Key);
+                        o.HDKeyPaths.Add(keypath.Key, Tuple.Create(rootFP, newKeyPath));
+                    }
+                }
+            }
             return psbt;
         }
 
@@ -290,7 +325,7 @@ namespace BTCPayServer.Controllers
             if (walletId?.StoreId == null)
                 return NotFound();
             var store = await Repository.FindStore(walletId.StoreId, GetUserId());
-            DerivationStrategy paymentMethod = GetPaymentMethod(walletId, store);
+            DerivationSchemeSettings paymentMethod = GetPaymentMethod(walletId, store);
             if (paymentMethod == null)
                 return NotFound();
             var network = this.NetworkProvider.GetNetwork(walletId?.CryptoCode);
@@ -321,7 +356,7 @@ namespace BTCPayServer.Controllers
             if (walletId?.StoreId == null)
                 return NotFound();
             var store = await Repository.FindStore(walletId.StoreId, GetUserId());
-            DerivationStrategy paymentMethod = GetPaymentMethod(walletId, store);
+            DerivationSchemeSettings paymentMethod = GetPaymentMethod(walletId, store);
             if (paymentMethod == null)
                 return NotFound();
 
@@ -330,7 +365,7 @@ namespace BTCPayServer.Controllers
             vm.IsServerAdmin = User.Claims.Any(c => c.Type == Policies.CanModifyServerSettings.Key && c.Value == "true");
             vm.IsSupportedByCurrency = _dashboard.Get(walletId.CryptoCode)?.Status?.BitcoinStatus?.Capabilities?.CanScanTxoutSet == true;
             var explorer = ExplorerClientProvider.GetExplorerClient(walletId.CryptoCode);
-            var scanProgress = await explorer.GetScanUTXOSetInformationAsync(paymentMethod.DerivationStrategyBase);
+            var scanProgress = await explorer.GetScanUTXOSetInformationAsync(paymentMethod.AccountDerivation);
             if (scanProgress != null)
             {
                 vm.PreviousError = scanProgress.Error;
@@ -365,13 +400,13 @@ namespace BTCPayServer.Controllers
             if (walletId?.StoreId == null)
                 return NotFound();
             var store = await Repository.FindStore(walletId.StoreId, GetUserId());
-            DerivationStrategy paymentMethod = GetPaymentMethod(walletId, store);
+            DerivationSchemeSettings paymentMethod = GetPaymentMethod(walletId, store);
             if (paymentMethod == null)
                 return NotFound();
             var explorer = ExplorerClientProvider.GetExplorerClient(walletId.CryptoCode);
             try
             {
-                await explorer.ScanUTXOSetAsync(paymentMethod.DerivationStrategyBase, vm.BatchSize, vm.GapLimit, vm.StartingIndex);
+                await explorer.ScanUTXOSetAsync(paymentMethod.AccountDerivation, vm.BatchSize, vm.GapLimit, vm.StartingIndex);
             }
             catch (NBXplorerException ex) when (ex.Error.Code == "scanutxoset-in-progress")
             {
@@ -393,14 +428,14 @@ namespace BTCPayServer.Controllers
             return null;
         }
 
-        private DerivationStrategy GetPaymentMethod(WalletId walletId, StoreData store)
+        private DerivationSchemeSettings GetPaymentMethod(WalletId walletId, StoreData store)
         {
             if (store == null || !store.HasClaim(Policies.CanModifyStoreSettings.Key))
                 return null;
 
             var paymentMethod = store
                             .GetSupportedPaymentMethods(NetworkProvider)
-                            .OfType<DerivationStrategy>()
+                            .OfType<DerivationSchemeSettings>()
                             .FirstOrDefault(p => p.PaymentId.PaymentType == Payments.PaymentTypes.BTCLike && p.PaymentId.CryptoCode == walletId.CryptoCode);
             return paymentMethod;
         }
@@ -447,7 +482,7 @@ namespace BTCPayServer.Controllers
             int account = 0,
             // sendtoaddress
             bool noChange = false,
-            string destination = null, string amount = null, string feeRate = null, bool substractFees = false
+            string destination = null, string amount = null, string feeRate = null, bool substractFees = false, bool disableRBF = false
             )
         {
             if (!HttpContext.WebSockets.IsWebSocketRequest)
@@ -455,7 +490,7 @@ namespace BTCPayServer.Controllers
 
             var cryptoCode = walletId.CryptoCode;
             var storeData = (await Repository.FindStore(walletId.StoreId, GetUserId()));
-            var derivationScheme = GetPaymentMethod(walletId, storeData).DerivationStrategyBase;
+            var derivationSettings = GetPaymentMethod(walletId, storeData);
 
             var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
 
@@ -511,6 +546,7 @@ namespace BTCPayServer.Controllers
 
                     model.SubstractFees = substractFees;
                     model.NoChange = noChange;
+                    model.DisableRBF = disableRBF;
                     if (command == "test")
                     {
                         result = await hw.Test(normalOperationTimeout.Token);
@@ -520,39 +556,24 @@ namespace BTCPayServer.Controllers
                         if (!_dashboard.IsFullySynched(network.CryptoCode, out var summary))
                             throw new Exception($"{network.CryptoCode}: not started or fully synched");
 
-                        var psbt = await CreatePSBT(network, derivationScheme, model, normalOperationTimeout.Token);
+                        
 
-                        var strategy = GetDirectDerivationStrategy(derivationScheme);
-                        var storeBlob = storeData.GetStoreBlob();
-                        var paymentId = new Payments.PaymentMethodId(cryptoCode, Payments.PaymentTypes.BTCLike);
-                        var foundKeyPath = storeBlob.GetWalletKeyPathRoot(paymentId);
+                        var strategy = GetDirectDerivationStrategy(derivationSettings.AccountDerivation);
                         // Some deployment have the wallet root key path saved in the store blob
                         // If it does, we only have to make 1 call to the hw to check if it can sign the given strategy,
-                        if (foundKeyPath == null || !await hw.CanSign(network, strategy, foundKeyPath, normalOperationTimeout.Token))
+                        if (derivationSettings.AccountKeyPath == null || !await hw.CanSign(network, strategy, derivationSettings.AccountKeyPath, normalOperationTimeout.Token))
                         {
                             // If the saved wallet key path is not present or incorrect, let's scan the wallet to see if it can sign strategy
-                            foundKeyPath = await hw.FindKeyPath(network, strategy, normalOperationTimeout.Token);
+                            var foundKeyPath = await hw.FindKeyPath(network, strategy, normalOperationTimeout.Token);
                             if (foundKeyPath == null)
                                 throw new HardwareWalletException($"This store is not configured to use this ledger");
-                            storeBlob.SetWalletKeyPathRoot(paymentId, foundKeyPath);
-                            storeData.SetStoreBlob(storeBlob);
+                            derivationSettings.AccountKeyPath = foundKeyPath;
+                            storeData.SetSupportedPaymentMethod(derivationSettings);
                             await Repository.UpdateStore(storeData);
                         }
 
-                        // NBX only know the path relative to the account xpub.
-                        // Here we rebase the hd_keys in the PSBT to have a keypath relative to the root HD so the wallet can sign
-                        // Note that the fingerprint of the hd keys are now 0, which is wrong
-                        // However, hardware wallets does not give a damn, and sometimes does not even allow us to get this fingerprint anyway.
-                        foreach (var o in psbt.PSBT.Inputs.OfType<PSBTCoin>().Concat(psbt.PSBT.Outputs))
-                        {
-                            foreach (var keypath in o.HDKeyPaths.ToList())
-                            {
-                                var newKeyPath = foundKeyPath.Derive(keypath.Value.Item2);
-                                o.HDKeyPaths.Remove(keypath.Key);
-                                o.HDKeyPaths.Add(keypath.Key, Tuple.Create(default(HDFingerprint), newKeyPath));
-                            }
-                        }
 
+                        var psbt = await CreatePSBT(network, derivationSettings, model, normalOperationTimeout.Token);
                         signTimeout.CancelAfter(TimeSpan.FromMinutes(5));
                         psbt.PSBT = await hw.SignTransactionAsync(psbt.PSBT, psbt.ChangeAddress?.ScriptPubKey, signTimeout.Token);
                         if(!psbt.PSBT.TryFinalize(out var errors))
@@ -573,7 +594,7 @@ namespace BTCPayServer.Controllers
                             throw new Exception("Error while broadcasting: " + ex.Message);
                         }
                         var wallet = _walletProvider.GetWallet(network);
-                        wallet.InvalidateCache(derivationScheme);
+                        wallet.InvalidateCache(derivationSettings.AccountDerivation);
                         result = new SendToAddressResult() { TransactionId = transaction.GetHash().ToString() };
                     }
                 }

BTCPayServer/Data/StoreData.cs

@@ -73,7 +73,7 @@ namespace BTCPayServer.Data
                 if (networks.BTC != null)
                 {
                     btcReturned = true;
-                    yield return BTCPayServer.DerivationStrategy.Parse(DerivationStrategy, networks.BTC);
+                    yield return DerivationSchemeSettings.Parse(DerivationStrategy, networks.BTC);
                 }
             }
 
@@ -98,6 +98,11 @@ namespace BTCPayServer.Data
 #pragma warning restore CS0618
         }
 
+        public void SetSupportedPaymentMethod(ISupportedPaymentMethod supportedPaymentMethod)
+        {
+            SetSupportedPaymentMethod(null, supportedPaymentMethod);
+        }
+
         /// <summary>
         /// Set or remove a new supported payment method for the store
         /// </summary>
@@ -105,8 +110,16 @@ namespace BTCPayServer.Data
         /// <param name="supportedPaymentMethod">The payment method, or null to remove</param>
         public void SetSupportedPaymentMethod(PaymentMethodId paymentMethodId, ISupportedPaymentMethod supportedPaymentMethod)
         {
-            if (supportedPaymentMethod != null && paymentMethodId != supportedPaymentMethod.PaymentId)
-                throw new InvalidOperationException("Argument mismatch");
+            if (supportedPaymentMethod != null && paymentMethodId != null && paymentMethodId != supportedPaymentMethod.PaymentId)
+            {
+                throw new InvalidOperationException("Incoherent arguments, this should never happen");
+            }
+            if (supportedPaymentMethod == null && paymentMethodId == null)
+                throw new ArgumentException($"{nameof(supportedPaymentMethod)} or {nameof(paymentMethodId)} should be specified");
+            if (supportedPaymentMethod != null && paymentMethodId == null)
+            {
+                paymentMethodId = supportedPaymentMethod.PaymentId;
+            }
 
 #pragma warning disable CS0618
             JObject strategies = string.IsNullOrEmpty(DerivationStrategies) ? new JObject() : JObject.Parse(DerivationStrategies);
@@ -134,7 +147,7 @@ namespace BTCPayServer.Data
                 }
             }
 
-            if (!existing && supportedPaymentMethod == null && paymentMethodId.IsBTCOnChain)
+            if (!existing && supportedPaymentMethod == null && supportedPaymentMethod.PaymentId.IsBTCOnChain)
             {
                 DerivationStrategy = null;
             }
@@ -430,23 +443,9 @@ namespace BTCPayServer.Data
 
         [Obsolete("Use GetExcludedPaymentMethods instead")]
         public string[] ExcludedPaymentMethods { get; set; }
-#pragma warning disable CS0618 // Type or member is obsolete
-        public void SetWalletKeyPathRoot(PaymentMethodId paymentMethodId, KeyPath keyPath)
-        {
-            if (keyPath == null)
-                WalletKeyPathRoots.Remove(paymentMethodId.ToString());
-            else
-                WalletKeyPathRoots.AddOrReplace(paymentMethodId.ToString().ToLowerInvariant(), keyPath.ToString());
-        }
-        public KeyPath GetWalletKeyPathRoot(PaymentMethodId paymentMethodId)
-        {
-            if (WalletKeyPathRoots.TryGetValue(paymentMethodId.ToString().ToLowerInvariant(), out var k))
-                return KeyPath.Parse(k);
-            return null;
-        }
-#pragma warning restore CS0618 // Type or member is obsolete
-        [Obsolete("Use SetWalletKeyPathRoot/GetWalletKeyPathRoot instead")]
-        public Dictionary<string, string> WalletKeyPathRoots { get; set; } = new Dictionary<string, string>();
+
+        [Obsolete("Use DerivationSchemeSettings instead")]
+        public Dictionary<string, string> WalletKeyPathRoots { get; set; }
 
         public EmailSettings EmailSettings { get; set; }
         public bool RedirectAutomatically { get; set; }

BTCPayServer/DerivationSchemeParser.cs

@@ -12,14 +12,51 @@ namespace BTCPayServer
 {
     public class DerivationSchemeParser
     {
-        public Network Network { get; set; }
+        public BTCPayNetwork BtcPayNetwork { get; }
+
+        public Network Network => BtcPayNetwork.NBitcoinNetwork;
+
         public Script HintScriptPubKey { get; set; }
 
-        public DerivationSchemeParser(Network expectedNetwork)
+        Dictionary<uint, string[]> ElectrumMapping = new Dictionary<uint, string[]>();
+        
+        public DerivationSchemeParser(BTCPayNetwork expectedNetwork)
         {
-            Network = expectedNetwork;
+            if (expectedNetwork == null)
+                throw new ArgumentNullException(nameof(expectedNetwork));
+            BtcPayNetwork = expectedNetwork;
         }
 
+
+        public DerivationStrategyBase ParseElectrum(string str)
+        {
+            
+            if (str == null)
+                throw new ArgumentNullException(nameof(str));
+            str = str.Trim();
+            var data = Network.GetBase58CheckEncoder().DecodeData(str);
+            if (data.Length < 4)
+                throw new FormatException();
+            var prefix = Utils.ToUInt32(data, false);
+
+            var standardPrefix = Utils.ToBytes(0x0488b21eU, false);
+            for (int ii = 0; ii < 4; ii++)
+                data[ii] = standardPrefix[ii];
+            var extPubKey = new BitcoinExtPubKey(Network.GetBase58CheckEncoder().EncodeData(data), Network.Main).ToNetwork(Network);
+            if (!BtcPayNetwork.ElectrumMapping.TryGetValue(prefix, out var type))
+            {
+                throw new FormatException();
+            }
+            if (type == DerivationType.Segwit)
+                return new DirectDerivationStrategy(extPubKey) { Segwit = true };
+            if (type == DerivationType.Legacy)
+                return new DirectDerivationStrategy(extPubKey) { Segwit = false };
+            if (type == DerivationType.SegwitP2SH)
+                return new DerivationStrategyFactory(Network).Parse(extPubKey.ToString() + "-[p2sh]");
+            throw new FormatException();
+        }
+
+
         public DerivationStrategyBase Parse(string str)
         {
             if (str == null)
@@ -41,7 +78,7 @@ namespace BTCPayServer
                 }
             }
 
-            if(!Network.Consensus.SupportSegwit)
+            if (!Network.Consensus.SupportSegwit)
                 hintedLabels.Add("legacy");
 
             try
@@ -53,15 +90,6 @@ namespace BTCPayServer
             {
             }
 
-            Dictionary<uint, string[]> electrumMapping = new Dictionary<uint, string[]>();
-            //Source https://github.com/spesmilo/electrum/blob/9edffd17542de5773e7284a8c8a2673c766bb3c3/lib/bitcoin.py
-            var standard = 0x0488b21eU;
-            electrumMapping.Add(standard, new[] { "legacy" });
-            var p2wpkh_p2sh = 0x049d7cb2U;
-            electrumMapping.Add(p2wpkh_p2sh, new string[] { "p2sh" });
-            var p2wpkh = 0x4b24746U;
-            electrumMapping.Add(p2wpkh, Array.Empty<string>());
-
             var parts = str.Split('-');
             bool hasLabel = false;
             for (int i = 0; i < parts.Length; i++)
@@ -84,17 +112,22 @@ namespace BTCPayServer
                     if (data.Length < 4)
                         continue;
                     var prefix = Utils.ToUInt32(data, false);
-                    var standardPrefix = Utils.ToBytes(Network.NetworkType == NetworkType.Mainnet ? 0x0488b21eU : 0x043587cf, false);
+
+                    var standardPrefix = Utils.ToBytes(0x0488b21eU, false);
                     for (int ii = 0; ii < 4; ii++)
                         data[ii] = standardPrefix[ii];
+                    var derivationScheme = new BitcoinExtPubKey(Network.GetBase58CheckEncoder().EncodeData(data), Network.Main).ToNetwork(Network).ToString();
 
-                    var derivationScheme = new BitcoinExtPubKey(Network.GetBase58CheckEncoder().EncodeData(data), Network).ToString();
-                    electrumMapping.TryGetValue(prefix, out string[] labels);
-                    if (labels != null)
+                    if (BtcPayNetwork.ElectrumMapping.TryGetValue(prefix, out var type))
                     {
-                        foreach (var label in labels)
+                        switch (type)
                         {
-                            hintedLabels.Add(label.ToLowerInvariant());
+                            case DerivationType.Legacy:
+                                hintedLabels.Add("legacy");
+                                break;
+                            case DerivationType.SegwitP2SH:
+                                hintedLabels.Add("p2sh");
+                                break;
                         }
                     }
                     parts[i] = derivationScheme;
@@ -136,7 +169,7 @@ namespace BTCPayServer
             resultNoLabels = string.Join('-', resultNoLabels.Split('-').Where(p => !IsLabel(p)));
             foreach (var labels in ItemCombinations(hintLabels.ToList()))
             {
-                var hinted = facto.Parse(resultNoLabels + '-' + string.Join('-', labels.Select(l=>$"[{l}]").ToArray()));
+                var hinted = facto.Parse(resultNoLabels + '-' + string.Join('-', labels.Select(l => $"[{l}]").ToArray()));
                 if (HintScriptPubKey == hinted.Derive(firstKeyPath).ScriptPubKey)
                     return hinted;
             }
@@ -149,20 +182,20 @@ namespace BTCPayServer
         }
 
         /// <summary>
-		/// Method to create lists containing possible combinations of an input list of items. This is 
-		/// basically copied from code by user "jaolho" on this thread:
-		/// http://stackoverflow.com/questions/7802822/all-possible-combinations-of-a-list-of-values
-		/// </summary>
-		/// <typeparam name="T">type of the items on the input list</typeparam>
-		/// <param name="inputList">list of items</param>
-		/// <param name="minimumItems">minimum number of items wanted in the generated combinations, 
-		///                            if zero the empty combination is included,
-		///                            default is one</param>
-		/// <param name="maximumItems">maximum number of items wanted in the generated combinations,
-		///                            default is no maximum limit</param>
-		/// <returns>list of lists for possible combinations of the input items</returns>
-		public static List<List<T>> ItemCombinations<T>(List<T> inputList, int minimumItems = 1,
-                                                        int maximumItems = int.MaxValue)
+        /// Method to create lists containing possible combinations of an input list of items. This is
+        /// basically copied from code by user "jaolho" on this thread:
+        /// http://stackoverflow.com/questions/7802822/all-possible-combinations-of-a-list-of-values
+        /// </summary>
+        /// <typeparam name="T">type of the items on the input list</typeparam>
+        /// <param name="inputList">list of items</param>
+        /// <param name="minimumItems">minimum number of items wanted in the generated combinations,
+        ///                            if zero the empty combination is included,
+        ///                            default is one</param>
+        /// <param name="maximumItems">maximum number of items wanted in the generated combinations,
+        ///                            default is no maximum limit</param>
+        /// <returns>list of lists for possible combinations of the input items</returns>
+        public static List<List<T>> ItemCombinations<T>(List<T> inputList, int minimumItems = 1,
+                                                int maximumItems = int.MaxValue)
         {
             int nonEmptyCombinations = (int)Math.Pow(2, inputList.Count) - 1;
             List<List<T>> listOfLists = new List<List<T>>(nonEmptyCombinations + 1);

BTCPayServer/DerivationSchemeSettings.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Payments;
+using NBitcoin;
+using NBXplorer.DerivationStrategy;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer
+{
+    public class DerivationSchemeSettings : ISupportedPaymentMethod
+    {
+        public static DerivationSchemeSettings Parse(string derivationStrategy, BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            if (derivationStrategy == null)
+                throw new ArgumentNullException(nameof(derivationStrategy));
+            var result = new NBXplorer.DerivationStrategy.DerivationStrategyFactory(network.NBitcoinNetwork).Parse(derivationStrategy);
+            return new DerivationSchemeSettings(result, network) { AccountOriginal = derivationStrategy.Trim() };
+        }
+
+        public static bool TryParseFromJson(string config, BTCPayNetwork network, out DerivationSchemeSettings strategy)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            if (config == null)
+                throw new ArgumentNullException(nameof(config));
+            strategy = null;
+            try
+            {
+                strategy = network.NBXplorerNetwork.Serializer.ToObject<DerivationSchemeSettings>(config);
+                strategy.Network = network;
+            }
+            catch { }
+            return strategy != null;
+        }
+
+        public static bool TryParseFromColdcard(string coldcardExport, BTCPayNetwork network, out DerivationSchemeSettings settings)
+        {
+            settings = null;
+            if (coldcardExport == null)
+                throw new ArgumentNullException(nameof(coldcardExport));
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            var result = new DerivationSchemeSettings();
+            result.Source = "Coldcard";
+            var derivationSchemeParser = new DerivationSchemeParser(network);
+            JObject jobj = null;
+            try
+            {
+                jobj = JObject.Parse(coldcardExport);
+                jobj = (JObject)jobj["keystore"];
+            }
+            catch
+            {
+                return false;
+            }
+
+            if (jobj.ContainsKey("xpub"))
+            {
+                try
+                {
+                    result.AccountOriginal = jobj["xpub"].Value<string>().Trim();
+                    result.AccountDerivation = derivationSchemeParser.ParseElectrum(result.AccountOriginal);
+                    if (result.AccountDerivation is DirectDerivationStrategy direct && !direct.Segwit)
+                        result.AccountOriginal = null; // Saving this would be confusing for user, as xpub of electrum is legacy derivation, but for btcpay, it is segwit derivation
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                return false;
+            }
+
+            if (jobj.ContainsKey("label"))
+            {
+                try
+                {
+                    result.Label = jobj["label"].Value<string>();
+                }
+                catch { return false; }
+            }
+
+            if (jobj.ContainsKey("ckcc_xfp"))
+            {
+                try
+                {
+                    result.RootFingerprint = new HDFingerprint(jobj["ckcc_xfp"].Value<uint>());
+                }
+                catch { return false; }
+            }
+
+            if (jobj.ContainsKey("derivation"))
+            {
+                try
+                {
+                    result.AccountKeyPath = new KeyPath(jobj["derivation"].Value<string>());
+                }
+                catch { return false; }
+            }
+            settings = result;
+            settings.Network = network;
+            return true;
+        }
+
+        public DerivationSchemeSettings()
+        {
+
+        }
+        public DerivationSchemeSettings(DerivationStrategyBase derivationStrategy, BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            if (derivationStrategy == null)
+                throw new ArgumentNullException(nameof(derivationStrategy));
+            AccountDerivation = derivationStrategy;
+            Network = network;
+        }
+        [JsonIgnore]
+        public BTCPayNetwork Network { get; set; }
+        public string Source { get; set; }
+        public KeyPath AccountKeyPath { get; set; }
+        
+        public DerivationStrategyBase AccountDerivation { get; set; }
+        public string AccountOriginal { get; set; }
+
+        public HDFingerprint? RootFingerprint { get; set; }
+
+        public string Label { get; set; }
+
+        [JsonIgnore]
+        public PaymentMethodId PaymentId => new PaymentMethodId(Network.CryptoCode, PaymentTypes.BTCLike);
+
+        public override string ToString()
+        {
+            return AccountDerivation.ToString();
+        }
+        public string ToPrettyString()
+        {
+            return !string.IsNullOrEmpty(Label) ? Label :
+                   !String.IsNullOrEmpty(AccountOriginal) ? AccountOriginal :
+                   ToString();
+        }
+
+        public string ToJson()
+        {
+            return Network.NBXplorerNetwork.Serializer.ToString(this);
+        }
+    }
+}

BTCPayServer/DerivationStrategy.cs

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

BTCPayServer/HostedServices/MigratorHostedService.cs

@@ -71,6 +71,12 @@ namespace BTCPayServer.HostedServices
                     settings.ConvertCrowdfundOldSettings = true;
                     await _Settings.UpdateSetting(settings);
                 }
+                if (!settings.ConvertWalletKeyPathRoots)
+                {
+                    await ConvertConvertWalletKeyPathRoots();
+                    settings.ConvertWalletKeyPathRoots = true;
+                    await _Settings.UpdateSetting(settings);
+                }
             }
             catch (Exception ex)
             {
@@ -79,6 +85,35 @@ namespace BTCPayServer.HostedServices
             }
         }
 
+        private async Task ConvertConvertWalletKeyPathRoots()
+        {
+            bool save = false;
+            using (var ctx = _DBContextFactory.CreateContext())
+            {
+                foreach (var store in await ctx.Stores.ToArrayAsync())
+                {
+#pragma warning disable CS0618 // Type or member is obsolete
+                    var blob = store.GetStoreBlob();
+                    if (blob.WalletKeyPathRoots == null)
+                        continue;
+                    foreach (var scheme in store.GetSupportedPaymentMethods(_NetworkProvider).OfType<DerivationSchemeSettings>())
+                    {
+                        if (blob.WalletKeyPathRoots.TryGetValue(scheme.PaymentId.ToString().ToLowerInvariant(), out var root))
+                        {
+                            scheme.AccountKeyPath = new NBitcoin.KeyPath(root);
+                            store.SetSupportedPaymentMethod(scheme);
+                            save = true;
+                        }
+                    }
+                    blob.WalletKeyPathRoots = null;
+                    store.SetStoreBlob(blob);
+#pragma warning restore CS0618 // Type or member is obsolete
+                }
+                if (save)
+                    await ctx.SaveChangesAsync();
+            }
+        }
+
         private async Task ConvertCrowdfundOldSettings()
         {
             using (var ctx = _DBContextFactory.CreateContext())
@@ -159,7 +194,7 @@ namespace BTCPayServer.HostedServices
                         if (lightning.IsLegacy)
                         {
                             method.SetLightningUrl(lightning);
-                            store.SetSupportedPaymentMethod(method.PaymentId, method);
+                            store.SetSupportedPaymentMethod(method);
                         }
                     }
                 }

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -176,7 +176,7 @@ namespace BTCPayServer.Hosting
             services.AddSingleton<IHostedService, CssThemeManagerHostedService>();
             services.AddSingleton<IHostedService, MigratorHostedService>();
 
-            services.AddSingleton<Payments.IPaymentMethodHandler<DerivationStrategy>, Payments.Bitcoin.BitcoinLikePaymentHandler>();
+            services.AddSingleton<Payments.IPaymentMethodHandler<DerivationSchemeSettings>, Payments.Bitcoin.BitcoinLikePaymentHandler>();
             services.AddSingleton<IHostedService, Payments.Bitcoin.NBXplorerListener>();
 
             services.AddSingleton<IHostedService, HostedServices.CheckConfigurationHostedService>();

BTCPayServer/Models/StoreViewModels/DerivationSchemeViewModel.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Rendering;
 using NBitcoin;
 
@@ -32,5 +33,9 @@ namespace BTCPayServer.Models.StoreViewModels
 
         public string StatusMessage { get; internal set; }
         public KeyPath RootKeyPath { get; set; }
+
+        [Display(Name = "Coldcard Wallet File")]
+        public IFormFile ColdcardPublicFile{ get; set; }
+        public string Config { get; set; }
     }
 }

BTCPayServer/Models/WalletViewModels/WalletSendLedgerModel.cs

@@ -9,6 +9,7 @@ namespace BTCPayServer.Models.WalletViewModels
     {
         public int FeeSatoshiPerByte { get; set; }
         public bool SubstractFees { get; set; }
+        public bool DisableRBF { get; set; }
         public decimal Amount { get; set; }
         public string Destination { get; set; }
         public bool NoChange { get; set; }

BTCPayServer/Models/WalletViewModels/WalletSendModel.cs

@@ -35,5 +35,8 @@ namespace BTCPayServer.Models.WalletViewModels
         public int Divisibility { get; set; }
         public string Fiat { get; set; }
         public string RateError { get; set; }
+        public bool SupportRBF { get; set; }
+        [Display(Name = "Disable RBF")]
+        public bool DisableRBF { get; set; }
     }
 }

BTCPayServer/Payments/Bitcoin/BitcoinLikePaymentHandler.cs

@@ -10,7 +10,7 @@ using NBitcoin;
 
 namespace BTCPayServer.Payments.Bitcoin
 {
-    public class BitcoinLikePaymentHandler : PaymentMethodHandlerBase<DerivationStrategy>
+    public class BitcoinLikePaymentHandler : PaymentMethodHandlerBase<DerivationSchemeSettings>
     {
         ExplorerClientProvider _ExplorerProvider;
         private IFeeProviderFactory _FeeRateProviderFactory;
@@ -33,16 +33,16 @@ namespace BTCPayServer.Payments.Bitcoin
             public Task<BitcoinAddress> ReserveAddress;
         }
 
-        public override object PreparePayment(DerivationStrategy supportedPaymentMethod, StoreData store, BTCPayNetwork network)
+        public override object PreparePayment(DerivationSchemeSettings supportedPaymentMethod, StoreData store, BTCPayNetwork network)
         {
             return new Prepare()
             {
                 GetFeeRate = _FeeRateProviderFactory.CreateFeeProvider(network).GetFeeRateAsync(),
-                ReserveAddress = _WalletProvider.GetWallet(network).ReserveAddressAsync(supportedPaymentMethod.DerivationStrategyBase)
+                ReserveAddress = _WalletProvider.GetWallet(network).ReserveAddressAsync(supportedPaymentMethod.AccountDerivation)
             };
         }
 
-        public override async Task<IPaymentMethodDetails> CreatePaymentMethodDetails(DerivationStrategy supportedPaymentMethod, PaymentMethod paymentMethod, StoreData store, BTCPayNetwork network, object preparePaymentObject)
+        public override async Task<IPaymentMethodDetails> CreatePaymentMethodDetails(DerivationSchemeSettings supportedPaymentMethod, PaymentMethod paymentMethod, StoreData store, BTCPayNetwork network, object preparePaymentObject)
         {
             if (!_ExplorerProvider.IsAvailable(network))
                 throw new PaymentMethodUnavailableException($"Full node not available");

BTCPayServer/Payments/Bitcoin/NBXplorerListener.cs

@@ -345,8 +345,8 @@ namespace BTCPayServer.Payments.Bitcoin
 
         private DerivationStrategyBase GetDerivationStrategy(InvoiceEntity invoice, BTCPayNetwork network)
         {
-            return invoice.GetSupportedPaymentMethod<DerivationStrategy>(new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike), _ExplorerClients.NetworkProviders)
-                          .Select(d => d.DerivationStrategyBase)
+            return invoice.GetSupportedPaymentMethod<DerivationSchemeSettings>(new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike), _ExplorerClients.NetworkProviders)
+                          .Select(d => d.AccountDerivation)
                           .FirstOrDefault();
         }
 

BTCPayServer/Payments/PaymentMethodExtensions.cs

@@ -12,10 +12,19 @@ namespace BTCPayServer.Payments
     {
         public static ISupportedPaymentMethod Deserialize(PaymentMethodId paymentMethodId, JToken value, BTCPayNetwork network)
         {
-            // Legacy
             if (paymentMethodId.PaymentType == PaymentTypes.BTCLike)
             {
-                return BTCPayServer.DerivationStrategy.Parse(((JValue)value).Value<string>(), network);
+                if (value is JObject jobj)
+                {
+                    var scheme = network.NBXplorerNetwork.Serializer.ToObject<DerivationSchemeSettings>(jobj);
+                    scheme.Network = network;
+                    return scheme;
+                }
+                // Legacy
+                else
+                {
+                    return BTCPayServer.DerivationSchemeSettings.Parse(((JValue)value).Value<string>(), network);
+                }
             }
             //////////
             else if (paymentMethodId.PaymentType == PaymentTypes.LightningLike)
@@ -44,7 +53,9 @@ namespace BTCPayServer.Payments
             // Legacy
             if (factory.PaymentId.PaymentType == PaymentTypes.BTCLike)
             {
-                return new JValue(((DerivationStrategy)factory).DerivationStrategyBase.ToString());
+                var derivation = (DerivationSchemeSettings)factory;
+                var str = derivation.Network.NBXplorerNetwork.Serializer.ToString(derivation);
+                return JObject.Parse(str);
             }
             //////////////
             else

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -225,7 +225,7 @@ namespace BTCPayServer.Services.Invoices
             {
                 if (networks.BTC != null)
                 {
-                    yield return BTCPayServer.DerivationStrategy.Parse(DerivationStrategy, networks.BTC);
+                    yield return BTCPayServer.DerivationSchemeSettings.Parse(DerivationStrategy, networks.BTC);
                 }
             }
 #pragma warning restore CS0618
@@ -238,8 +238,8 @@ namespace BTCPayServer.Services.Invoices
             {
                 obj.Add(strat.PaymentId.ToString(), PaymentMethodExtensions.Serialize(strat));
 #pragma warning disable CS0618
-                if (strat.PaymentId.IsBTCOnChain)
-                    DerivationStrategy = ((JValue)PaymentMethodExtensions.Serialize(strat)).Value<string>();
+                // This field should eventually disappear
+                DerivationStrategy = null;
             }
             DerivationStrategies = JsonConvert.SerializeObject(obj);
 #pragma warning restore CS0618

BTCPayServer/Services/MigrationSettings.cs

@@ -12,5 +12,6 @@ namespace BTCPayServer.Services
         public bool ConvertMultiplierToSpread { get; set; }
         public bool ConvertNetworkFeeProperty { get; set; }
         public bool ConvertCrowdfundOldSettings { get; set; }
+        public bool ConvertWalletKeyPathRoots { get; set; }
     }
 }

BTCPayServer/U2F/U2FService.cs

@@ -187,24 +187,26 @@ namespace BTCPayServer.Services.U2F
                 var requests = new List<U2FDeviceAuthenticationRequest>();
 
 
-                var challenge = global::U2F.Core.Crypto.U2F.GenerateChallenge();
 
                 var serverChallenges = new List<ServerChallenge>();
                 foreach (var registeredDevice in devices)
                 {
-                    serverChallenges.Add(new ServerChallenge
-                    {
-                        appId = appId,
-                        challenge = challenge,
-                        keyHandle = registeredDevice.KeyHandle.ByteArrayToBase64String(),
-                        version = global::U2F.Core.Crypto.U2F.U2FVersion,
-                    });
-
+                   var challenge =  global::U2F.Core.Crypto.U2F.StartAuthentication(appId,
+                       new DeviceRegistration(registeredDevice.KeyHandle, registeredDevice.PublicKey,
+                           registeredDevice.AttestationCert, (uint)registeredDevice.Counter));
+                   serverChallenges.Add(new ServerChallenge()
+                   {
+                       challenge = challenge.Challenge,
+                       appId = challenge.AppId,
+                       version = challenge.Version,
+                       keyHandle = challenge.KeyHandle
+                   });
+                   
                     requests.Add(
                         new U2FDeviceAuthenticationRequest()
                         {
                             AppId = appId,
-                            Challenge = challenge,
+                            Challenge = challenge.Challenge,
                             KeyHandle = registeredDevice.KeyHandle.ByteArrayToBase64String(),
                             Version = global::U2F.Core.Crypto.U2F.U2FVersion
                         });

BTCPayServer/Views/Stores/AddDerivationScheme.cshtml

@@ -14,6 +14,33 @@
 </div>
 <div class="row">
     <div class="col-md-8">
+    
+        <div class="modal fade" id="coldcardimport" tabindex="-1" role="dialog" aria-labelledby="coldcardimport" aria-hidden="true">
+            <div class="modal-dialog" role="document">
+                <form class="modal-content" form method="post" enctype="multipart/form-data">
+                    <div class="modal-header">
+                        <h5 class="modal-title" id="exampleModalLabel">Import Coldcard Wallet</h5>
+                        <button type="button" class="close" data-dismiss="modal" aria-label="Close">
+                            <span aria-hidden="true">&times;</span>
+                        </button>
+                    </div>
+                    <div class="modal-body">
+                        <p>You may import your Coldcard wallet by exporting the public details from <kbd>Advanced->MicroSD Card->Electrum Wallet</kbd> and uploading it here.</p>
+                        <div class="form-group">
+                            <label asp-for="ColdcardPublicFile"></label>
+                            
+                            <input type="file" class="form-control-file"  asp-for="ColdcardPublicFile" required>
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-secondary" data-dismiss="modal">Close</button>
+                        <button type="submit" class="btn btn-primary">Submit</button>
+                    </div>
+                    
+                </form>
+            </div>
+        </div>
+    
         <form method="post">
             @if (!Model.Confirmation)
             {
@@ -23,6 +50,7 @@
                 </div>
                 <input id="CryptoCurrency" asp-for="CryptoCode" type="hidden" />
                 <input id="KeyPath" asp-for="KeyPath" type="hidden" />
+                <input id="Config" asp-for="Config" type="hidden" />
                 <div class="form-group">
                     <label asp-for="DerivationScheme"></label>
                     <input asp-for="DerivationScheme" class="form-control" />
@@ -36,9 +64,15 @@
                     <p id="no-ledger-info" class="form-text text-muted" style="display: none;">
                         No ledger wallet detected. If you own one, use chrome, open the app, and refresh this page.
                     </p>
-                    <div id="ledger-info" class="form-text text-muted" style="display: none;">
+                    <div id="ledger-info" class="form-text text-muted display-when-ledger-connected">
                         <span>A ledger wallet is detected, which account do you want to use? No need to paste manually xpub if your ledger device was detected. Just select derivation scheme from the list bellow and xpub will automatically populate.</span>
-                        <div class="dropdown">
+
+                    </div>
+                    <div class="d-flex">
+                        <button type="button" class="btn btn-primary mr-2 " data-toggle="modal" data-target="#coldcardimport">
+                            Import Coldcard wallet
+                        </button>
+                        <div class="dropdown display-when-ledger-connected">
                             <button class="btn btn-primary dropdown-toggle" type="button" id="ledgerAccountsDropdownMenuButton" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
                                 Select ledger wallet account
                             </button>
@@ -49,7 +83,11 @@
                                 }
                             </div>
                         </div>
+
+
                     </div>
+
+
                 </div>
                 <div class="form-group">
                     <span>BTCPay format memo</span>
@@ -104,6 +142,7 @@
                 <input id="KeyPath" asp-for="KeyPath" type="hidden" />
                 <input type="hidden" asp-for="DerivationScheme" />
                 <input type="hidden" asp-for="Enabled" />
+                <input id="Config" asp-for="Config" type="hidden" />
                 <div class="form-group">
                     <table class="table table-sm table-responsive-md">
                         <thead>

BTCPayServer/Views/Wallets/WalletSend.cshtml

@@ -71,6 +71,14 @@
                             <a href="https://docs.btcpayserver.org/features/wallet#make-sure-no-change-utxo-is-created-expert-mode" target="_blank"><span class="fa fa-question-circle-o" title="More information..."></span></a>
                             <input asp-for="NoChange" class="form-check" />
                         </div>
+                        @if (Model.SupportRBF)
+                        {
+                        <div class="form-group">
+                            <label asp-for="DisableRBF"></label>
+                            <a href="https://bitcoin.org/en/glossary/rbf" target="_blank"><span class="fa fa-question-circle-o" title="More information..."></span></a>
+                            <input asp-for="DisableRBF" class="form-check" />
+                        </div>
+                        }
                     </div>
                 </div>
             </div>

BTCPayServer/Views/Wallets/WalletSendLedger.cshtml

@@ -15,6 +15,7 @@
         <input type="hidden" asp-for="Destination" />
         <input type="hidden" asp-for="Amount" />
         <input type="hidden" asp-for="FeeSatoshiPerByte" />
+        <input type="hidden" asp-for="DisableRBF" />
         <input type="hidden" asp-for="SubstractFees" />
         <input type="hidden" asp-for="NoChange" />
         <p>

BTCPayServer/wwwroot/js/StoreAddDerivationScheme.js

@@ -24,7 +24,7 @@
         $("#ledger-loading").css("display", id === "ledger-loading" ? "block" : "none");
         $("#no-ledger-info").css("display", id === "no-ledger-info" ? "block" : "none");
         $("#ledger-validate").css("display", id === "ledger-validate" ? "block" : "none");
-        $("#ledger-info").css("display", id === "ledger-info" ? "block" : "none");
+        $(".display-when-ledger-connected").css("display", id === "ledger-info" ? "block" : "none");
     }
     function Write(prefix, type, message) {
         if (type === "error") {

BTCPayServer/wwwroot/js/WalletSendLedger.js

@@ -4,6 +4,7 @@
     var fee = $("#FeeSatoshiPerByte").val();
     var substractFee = $("#SubstractFees").val();
     var noChange = $("#NoChange").val();
+    var disableRBF = $("#DisableRBF").val();
 
     var loc = window.location, ws_uri;
     if (loc.protocol === "https:") {
@@ -48,6 +49,7 @@
         args += "&feeRate=" + fee;
         args += "&substractFees=" + substractFee;
         args += "&noChange=" + noChange;
+        args += "&disableRBF=" + disableRBF;
 
         if (noChange === "True") {
             WriteAlert("warning", 'WARNING: Because you want to make sure no change UTXO is created, you will end up sending more than the chosen amount to your destination. Please validate the transaction on your ledger');

BTCPayServer/wwwroot/locales/es-ES.json

@@ -6,7 +6,7 @@
   "Awaiting Payment...": "Esperando el pago...",
   "Pay with": "Pagar con",
   "Contact and Refund Email": "Contacto y correo electrónico de reembolso",
-  "Contact_Body": "Por favor indica una dirección de correo electrónico a continuación. Nos pondremos en contacto contigo en esta dirección si hay algún problema con tu pago.",
+  "Contact_Body": "Por favor indica una dirección de correo electrónico. Nos pondremos en contacto contigo en esta dirección si hay algún problema con tu pago.",
   "Your email": "Tu correo electrónico",
   "Continue": "Continuar",
   "Please enter a valid email address": "Por favor ingresa un correo electrónico válido",
@@ -18,12 +18,12 @@
   "Copy": "Copiar",
   "Conversion": "Conversión",
   "Open in wallet": "Abrir en la billetera",
-  "CompletePay_Body": "Para completar tu pago, envía {{btcDue}} {{cryptoCode}} a la siguiente dirección:",
+  "CompletePay_Body": "Para completar tu pago, envía exactamente {{btcDue}} {{cryptoCode}} a la siguiente dirección:",
   "Amount": "Cantidad",
   "Address": "Dirección",
   "Copied": "Copiado",
   "ConversionTab_BodyTop": "Puedes pagar {{btcDue}} {{cryptoCode}} usando altcoins que no soportamos directamente.",
-  "ConversionTab_BodyDesc": "Este servicio es prestado por terceros. Ten en cuenta que no tenemos control sobre cómo ellos re-enviarán tus fondos. La factura solo se marcará como pagada una vez se reciban los fondos en la cadena de bloques de {{cryptoCode}} .",
+  "ConversionTab_BodyDesc": "Este servicio es prestado por terceros. Ten en cuenta que no tenemos control sobre el reenvío de tus fondos. La factura solo se marcará como pagada una vez se reciban los fondos en la cadena de bloques de {{cryptoCode}} .",
   "ConversionTab_CalculateAmount_Error": "Reintentar",
   "ConversionTab_LoadCurrencies_Error": "Reintentar",
   "ConversionTab_Lightning": "No hay proveedores de conversión disponibles para los pagos con Lightning Network.",
@@ -32,7 +32,7 @@
   "Invoice expired": "La factura expiró",
   "What happened?": "¿Qué sucedió?",
   "InvoiceExpired_Body_1": "Esta factura ha expirado. Una factura solo es válida por {{maxTimeMinutes}} minutos. \nPuedes regresar a {{storeName}} si deseas volver a enviar tu pago.",
-  "InvoiceExpired_Body_2": "Si intentaste enviar un pago, aún no ha sido aceptado por la red de Bitcoin. Todavía no hemos recibido tus fondos.",
+  "InvoiceExpired_Body_2": "Si intentaste enviar un pago, aún no ha sido aceptado por la red. Todavía no hemos recibido tus fondos.",
   "InvoiceExpired_Body_3": "Si recibimos el pago despues, procesaremos tu orden o te contactaremos para un reembolso...",
   "Invoice ID": "ID de la factura",
   "Order ID": "ID del pedido",

BTCPayServer/wwwroot/main/css/site.css

@@ -19,3 +19,7 @@
 .only-for-js, .input-group-clear{
     display: none;
 }
+
+.display-when-ledger-connected{
+    display: none;
+}