fix electrum format for add derivation

BTCPayServer.Tests/docker-compose.yml

@@ -37,7 +37,7 @@ services:
       - postgres
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.1.12
+    image: nicolasdorier/nbxplorer:1.0.1.13
     ports:
       - "32838:32838"
     expose: 

BTCPayServer/BTCPayServer.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.1.22</Version>
+		<Version>1.0.1.26</Version>
     <NoWarn>NU1701</NoWarn>
   </PropertyGroup>
   <ItemGroup>

BTCPayServer/Controllers/StoresController.cs

@@ -120,61 +120,17 @@ namespace BTCPayServer.Controllers
             return HttpContext.Request.GetAbsoluteRoot() + "/stores/" + storeId + "/";
         }
 
-        class WebSocketTransport : LedgerWallet.Transports.ILedgerTransport
-        {
-            private readonly WebSocket webSocket;
-
-            public WebSocketTransport(System.Net.WebSockets.WebSocket webSocket)
-            {
-                if (webSocket == null)
-                    throw new ArgumentNullException(nameof(webSocket));
-                this.webSocket = webSocket;
-            }
-
-            public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(10);
-            public async Task<byte[][]> Exchange(byte[][] apdus)
-            {
-                List<byte[]> responses = new List<byte[]>();
-                using (CancellationTokenSource cts = new CancellationTokenSource(Timeout))
-                {
-                    foreach (var apdu in apdus)
-                    {
-                        await this.webSocket.SendAsync(new ArraySegment<byte>(apdu), WebSocketMessageType.Binary, true, cts.Token);
-                    }
-                    foreach (var apdu in apdus)
-                    {
-                        byte[] response = new byte[300];
-                        var result = await this.webSocket.ReceiveAsync(new ArraySegment<byte>(response), cts.Token);
-                        Array.Resize(ref response, result.Count);
-                        responses.Add(response);
-                    }
-                }
-                return responses.ToArray();
-            }
-        }
-
-        class LedgerTestResult
-        {
-            public bool Success { get; set; }
-            public string Error { get; set; }
-        }
-
-        class GetInfoResult
+        public class GetInfoResult
         {
             public int RecommendedSatoshiPerByte { get; set; }
             public double Balance { get; set; }
         }
 
-        class SendToAddressResult
+        public class SendToAddressResult
         {
             public string TransactionId { get; set; }
         }
 
-        class GetXPubResult
-        {
-            public string ExtPubKey { get; set; }
-        }
-
         [HttpGet]
         [Route("{storeId}/ws/ledger")]
         public async Task<IActionResult> LedgerConnection(
@@ -193,185 +149,131 @@ namespace BTCPayServer.Controllers
                 return NotFound();
 
             var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
-            var ledgerTransport = new WebSocketTransport(webSocket);
-            var ledger = new LedgerWallet.LedgerClient(ledgerTransport);
+
+            var hw = new HardwareWalletService(webSocket);
+            object result = null;
             try
             {
-                if (command == "test")
+                BTCPayNetwork network = null;
+                if (cryptoCode != null)
                 {
-                    var version = await ledger.GetFirmwareVersionAsync();
-                    await Send(webSocket, new LedgerTestResult() { Success = true });
-                }
-                if (command == "getxpub")
-                {
-                    var network = _NetworkProvider.GetNetwork(cryptoCode);
-                    try
-                    {
-                        var pubkey = await GetExtPubKey(ledger, network, new KeyPath("49'").Derive(network.CoinType).Derive(0, true));
-                        var derivation = new DerivationStrategyFactory(network.NBitcoinNetwork).CreateDirectDerivationStrategy(pubkey, new DerivationStrategyOptions()
-                        {
-                            P2SH = true,
-                            Legacy = false
-                        });
-                        await Send(webSocket, new GetXPubResult() { ExtPubKey = derivation.ToString() });
-                    }
-                    catch(FormatException)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = "Unsupported ledger app" });
-                    }
-                }
-                if (command == "getinfo")
-                {
-                    var network = _NetworkProvider.GetNetwork(cryptoCode);
-                    var strategy = store.GetDerivationStrategies(_NetworkProvider).FirstOrDefault(s => s.Network.NBitcoinNetwork == network.NBitcoinNetwork);
-                    if (strategy == null)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"Derivation strategy for {cryptoCode} is not set" });
-                        return new EmptyResult();
-                    }
-                    DirectDerivationStrategy directStrategy = GetDirectStrategy(strategy);
-                    if (directStrategy == null)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"The feature does not work for multi-sig wallets" });
-                        return new EmptyResult();
-                    }
-
-                    var foundKeyPath = await GetKeyPath(ledger, network, directStrategy);
-
-                    if (foundKeyPath == null)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"This store is not configured to use this ledger" });
-                        return new EmptyResult();
-                    }
-
-                    var feeProvider = _FeeRateProvider.CreateFeeProvider(network);
-                    var recommendedFees = feeProvider.GetFeeRateAsync();
-                    var balance = _WalletProvider.GetWallet(network).GetBalance(strategy.DerivationStrategyBase);
-
-                    await Send(webSocket, new GetInfoResult() { Balance = (double)(await balance).ToDecimal(MoneyUnit.BTC), RecommendedSatoshiPerByte = (int)(await recommendedFees).GetFee(1).Satoshi });
+                    network = _NetworkProvider.GetNetwork(cryptoCode);
+                    if (network == null)
+                        throw new FormatException("Invalid value for crypto code");
                 }
 
-                if (command == "sendtoaddress")
+                BitcoinAddress destinationAddress = null;
+                if (destination != null)
                 {
-                    var network = _NetworkProvider.GetNetwork(cryptoCode);
-                    var strategy = store.GetDerivationStrategies(_NetworkProvider).FirstOrDefault(s => s.Network.NBitcoinNetwork == network.NBitcoinNetwork);
-                    if (strategy == null)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"Derivation strategy for {cryptoCode} is not set" });
-                        return new EmptyResult();
-                    }
-
-                    DirectDerivationStrategy directStrategy = GetDirectStrategy(strategy);
-                    if (directStrategy == null)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"The feature does not work for multi-sig wallets" });
-                        return new EmptyResult();
-                    }
-
-                    var foundKeyPath = await GetKeyPath(ledger, network, directStrategy);
-
-                    if (foundKeyPath == null)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"This store is not configured to use this ledger" });
-                        return new EmptyResult();
-                    }
-
-                    BitcoinAddress destinationAddress = null;
                     try
                     {
-                        destinationAddress = BitcoinAddress.Create(destination.Trim());
-                    }
-                    catch
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"Invalid destination address" });
-                        return new EmptyResult();
+                        destinationAddress = BitcoinAddress.Create(destination);
                     }
+                    catch { }
+                    if (destinationAddress == null)
+                        throw new FormatException("Invalid value for destination");
+                }
 
-                    Money amountBTC = null;
-                    try
-                    {
-                        amountBTC = Money.Parse(amount);
-                    }
-                    catch
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"Invalid amount" });
-                        return new EmptyResult();
-                    }
-                    if (amount <= Money.Zero)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = "The amount should be above zero" });
-                        return new EmptyResult();
-                    }
-
-                    FeeRate feeRateValue = null;
+                FeeRate feeRateValue = null;
+                if (feeRate != null)
+                {
                     try
                     {
                         feeRateValue = new FeeRate(Money.Satoshis(int.Parse(feeRate)), 1);
                     }
-                    catch
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = "Invalid fee rate" });
-                        return new EmptyResult();
-                    }
+                    catch { }
+                    if (feeRateValue == null || feeRateValue.FeePerK <= Money.Zero)
+                        throw new FormatException("Invalid value for fee rate");
+                }
 
-                    if (feeRateValue.FeePerK <= Money.Zero)
-                    {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = "The fee rate should be above zero" });
-                        return new EmptyResult();
-                    }
-
-                    bool substractFeeBool = bool.Parse(substractFees);
-
-                    var wallet = _WalletProvider.GetWallet(network);
-                    var unspentCoins = await wallet.GetUnspentCoins(strategy.DerivationStrategyBase);
-
-                    TransactionBuilder builder = new TransactionBuilder();
-                    builder.AddCoins(unspentCoins.Item1);
-                    builder.Send(destinationAddress, amountBTC);
-                    if (substractFeeBool)
-                        builder.SubtractFees();
-                    var change = await wallet.GetChangeAddressAsync(strategy.DerivationStrategyBase);
-                    builder.SetChange(change.Item1);
-                    builder.SendEstimatedFees(feeRateValue);
-                    builder.Shuffle();
-                    var unsigned = builder.BuildTransaction(false);
-
-                    Dictionary<OutPoint, KeyPath> keyPaths = unspentCoins.Item2;
-                    var hasChange = unsigned.Outputs.Count == 2;
-                    var usedCoins = builder.FindSpentCoins(unsigned);
-                    ledgerTransport.Timeout = TimeSpan.FromMinutes(5);
-                    var fullySigned = await ledger.SignTransactionAsync(
-                        usedCoins.Select(c => new SignatureRequest
-                        {
-                            InputCoin = c,
-                            KeyPath = foundKeyPath.Derive(keyPaths[c.Outpoint]),
-                            PubKey = directStrategy.Root.Derive(keyPaths[c.Outpoint]).PubKey
-                        }).ToArray(),
-                        unsigned,
-                        hasChange ? foundKeyPath.Derive(change.Item2) : null);
+                Money amountBTC = null;
+                if (amount != null)
+                {
                     try
                     {
-                        var result = await wallet.BroadcastTransactionsAsync(new List<Transaction>() { fullySigned });
-                        if (!result[0].Success)
+                        amountBTC = Money.Parse(amount);
+                    }
+                    catch { }
+                    if (amountBTC == null || amountBTC <= Money.Zero)
+                        throw new FormatException("Invalid value for amount");
+                }
+
+                bool subsctractFeesValue = false;
+                if (substractFees != null)
+                {
+                    try
+                    {
+                        subsctractFeesValue = bool.Parse(substractFees);
+                    }
+                    catch { throw new FormatException("Invalid value for substract fees"); }
+                }
+                if (command == "test")
+                {
+                    result = await hw.Test();
+                }
+                if (command == "getxpub")
+                {
+                    result = await hw.GetExtPubKey(network);
+                }
+                if (command == "getinfo")
+                {
+                    var strategy = GetDirectDerivationStrategy(store, network);
+                    var strategyBase = GetDerivationStrategy(store, network);
+                    if (!await hw.SupportDerivation(network, strategy))
+                    {
+                        throw new Exception($"This store is not configured to use this ledger");
+                    }
+
+                    var feeProvider = _FeeRateProvider.CreateFeeProvider(network);
+                    var recommendedFees = feeProvider.GetFeeRateAsync();
+                    var balance = _WalletProvider.GetWallet(network).GetBalance(strategyBase);
+                    result = new GetInfoResult() { Balance = (double)(await balance).ToDecimal(MoneyUnit.BTC), RecommendedSatoshiPerByte = (int)(await recommendedFees).GetFee(1).Satoshi };
+                }
+
+                if (command == "sendtoaddress")
+                {
+                    var strategy = GetDirectDerivationStrategy(store, network);
+                    var strategyBase = GetDerivationStrategy(store, network);
+                    var wallet = _WalletProvider.GetWallet(network);
+                    var change = wallet.GetChangeAddressAsync(strategyBase);
+                    var unspentCoins = await wallet.GetUnspentCoins(strategyBase);
+                    var changeAddress = await change;
+                    unspentCoins.Item2.TryAdd(changeAddress.Item1.ScriptPubKey, changeAddress.Item2);
+                    var transaction = await hw.SendToAddress(strategy, unspentCoins.Item1, network,
+                                            new[] { (destinationAddress as IDestination, amountBTC, subsctractFeesValue) },
+                                            feeRateValue,
+                                            changeAddress.Item1,
+                                            unspentCoins.Item2);
+                    try
+                    {
+                        var broadcastResult = await wallet.BroadcastTransactionsAsync(new List<Transaction>() { transaction });
+                        if (!broadcastResult[0].Success)
                         {
-                            await Send(webSocket, new LedgerTestResult() { Success = false, Error = $"RPC Error while broadcasting: {result[0].RPCCode} {result[0].RPCCodeMessage} {result[0].RPCMessage}" });
-                            return new EmptyResult();
+                            throw new Exception($"RPC Error while broadcasting: {broadcastResult[0].RPCCode} {broadcastResult[0].RPCCodeMessage} {broadcastResult[0].RPCMessage}");
                         }
                     }
                     catch (Exception ex)
                     {
-                        await Send(webSocket, new LedgerTestResult() { Success = false, Error = "Error while broadcasting: " + ex.Message });
-                        return new EmptyResult();
+                        throw new Exception("Error while broadcasting: " + ex.Message);
                     }
-                    await Send(webSocket, new SendToAddressResult() { TransactionId = fullySigned.GetHash().ToString() });
+                    result = new SendToAddressResult() { TransactionId = transaction.GetHash().ToString() };
                 }
             }
-            catch (LedgerWallet.LedgerWalletException ex)
-            { try { await Send(webSocket, new LedgerTestResult() { Success = false, Error = ex.Message }); } catch { } }
             catch (OperationCanceledException)
-            { try { await Send(webSocket, new LedgerTestResult() { Success = false, Error = "timeout" }); } catch { } }
+            { result = new LedgerTestResult() { Success = false, Error = "Timeout" }; }
             catch (Exception ex)
-            { try { await Send(webSocket, new LedgerTestResult() { Success = false, Error = ex.Message }); } catch { } }
+            { result = new LedgerTestResult() { Success = false, Error = ex.Message }; }
+
+            try
+            {
+                if (result != null)
+                {
+                    UTF8Encoding UTF8NOBOM = new UTF8Encoding(false);
+                    var bytes = UTF8NOBOM.GetBytes(JsonConvert.SerializeObject(result, _MvcJsonOptions.SerializerSettings));
+                    await webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, new CancellationTokenSource(2000).Token);
+                }
+            }
+            catch { }
             finally
             {
                 await webSocket.CloseSocket();
@@ -380,58 +282,26 @@ namespace BTCPayServer.Controllers
             return new EmptyResult();
         }
 
-        private static async Task<KeyPath> GetKeyPath(LedgerClient ledger, BTCPayNetwork network, DirectDerivationStrategy directStrategy)
+        private DirectDerivationStrategy GetDirectDerivationStrategy(StoreData store, BTCPayNetwork network)
         {
-            KeyPath foundKeyPath = null;
-            foreach (var account in
-                                  new[] { new KeyPath("49'"), new KeyPath("44'") }
-                                  .Select(purpose => purpose.Derive(network.CoinType))
-                                  .SelectMany(coinType => Enumerable.Range(0, 5).Select(i => coinType.Derive(i, true))))
-            {
-                try
-                {
-                    var extpubkey = await GetExtPubKey(ledger, network, account);
-                    if (directStrategy.ToString().Contains(extpubkey.ToString()))
-                    {
-                        foundKeyPath = account;
-                        break;
-                    }
-                }
-                catch (FormatException)
-                {
-                    throw new Exception($"The opened ledger app does not support {network.NBitcoinNetwork.Name}");
-                }
-            }
-
-            return foundKeyPath;
-        }
-
-        private static async Task<BitcoinExtPubKey> GetExtPubKey(LedgerClient ledger, BTCPayNetwork network, KeyPath account)
-        {
-            var pubKey = await ledger.GetWalletPubKeyAsync(account);
-            if (pubKey.Address.Network != network.NBitcoinNetwork)
-            {
-                if (network.DefaultSettings.ChainType == NBXplorer.ChainType.Main)
-                    throw new Exception($"The opened ledger app should be for {network.NBitcoinNetwork.Name}, not for {pubKey.Address.Network}");
-            }
-            var parent = (await ledger.GetWalletPubKeyAsync(account.Parent)).UncompressedPublicKey.Compress();
-            var extpubkey = new ExtPubKey(pubKey.UncompressedPublicKey.Compress(), pubKey.ChainCode, (byte)account.Indexes.Length, parent.Hash.ToBytes().Take(4).ToArray(), account.Indexes.Last()).GetWif(network.NBitcoinNetwork);
-            return extpubkey;
-        }
-
-        private static DirectDerivationStrategy GetDirectStrategy(DerivationStrategy strategy)
-        {
-            var directStrategy = strategy.DerivationStrategyBase as DirectDerivationStrategy;
+            var strategy = GetDerivationStrategy(store, network);
+            var directStrategy = strategy as DirectDerivationStrategy;
             if (directStrategy == null)
-                directStrategy = (strategy.DerivationStrategyBase as P2SHDerivationStrategy).Inner as DirectDerivationStrategy;
+                directStrategy = (strategy as P2SHDerivationStrategy).Inner as DirectDerivationStrategy;
+            if (!directStrategy.Segwit)
+                return null;
             return directStrategy;
         }
 
-        UTF8Encoding UTF8NOBOM = new UTF8Encoding(false);
-        private async Task Send(WebSocket webSocket, object result)
+        private DerivationStrategyBase GetDerivationStrategy(StoreData store, BTCPayNetwork network)
         {
-            var bytes = UTF8NOBOM.GetBytes(JsonConvert.SerializeObject(result, _MvcJsonOptions.SerializerSettings));
-            await webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, new CancellationTokenSource(2000).Token);
+            var strategy = store.GetDerivationStrategies(_NetworkProvider).FirstOrDefault(s => s.Network.NBitcoinNetwork == network.NBitcoinNetwork);
+            if (strategy == null)
+            {
+                throw new Exception($"Derivation strategy for {network.CryptoCode} is not set");
+            }
+
+            return strategy.DerivationStrategyBase;
         }
 
         [HttpGet]

BTCPayServer/Hosting/Startup.cs

@@ -95,7 +95,7 @@ namespace BTCPayServer.Hosting
             // Needed to debug U2F for ledger support
             //services.Configure<KestrelServerOptions>(kestrel =>
             //{
-            //    kestrel.Listen(IPAddress.Loopback, 5012, l => 
+            //    kestrel.Listen(IPAddress.Loopback, 5012, l =>
             //    {
             //        l.UseHttps("devtest.pfx", "toto");
             //    });

BTCPayServer/Services/HardwareWalletService.cs

@@ -0,0 +1,226 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+using LedgerWallet;
+using NBitcoin;
+using NBXplorer.DerivationStrategy;
+
+namespace BTCPayServer.Services
+{
+
+    public class HardwareWalletException : Exception
+    {
+        public HardwareWalletException() { }
+        public HardwareWalletException(string message) : base(message) { }
+        public HardwareWalletException(string message, Exception inner) : base(message, inner) { }
+    }
+    public class HardwareWalletService
+    {
+        class WebSocketTransport : LedgerWallet.Transports.ILedgerTransport
+        {
+            private readonly WebSocket webSocket;
+
+            public WebSocketTransport(System.Net.WebSockets.WebSocket webSocket)
+            {
+                if (webSocket == null)
+                    throw new ArgumentNullException(nameof(webSocket));
+                this.webSocket = webSocket;
+            }
+
+            public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(10);
+            public async Task<byte[][]> Exchange(byte[][] apdus)
+            {
+                List<byte[]> responses = new List<byte[]>();
+                using (CancellationTokenSource cts = new CancellationTokenSource(Timeout))
+                {
+                    foreach (var apdu in apdus)
+                    {
+                        await this.webSocket.SendAsync(new ArraySegment<byte>(apdu), WebSocketMessageType.Binary, true, cts.Token);
+                    }
+                    foreach (var apdu in apdus)
+                    {
+                        byte[] response = new byte[300];
+                        var result = await this.webSocket.ReceiveAsync(new ArraySegment<byte>(response), cts.Token);
+                        Array.Resize(ref response, result.Count);
+                        responses.Add(response);
+                    }
+                }
+                return responses.ToArray();
+            }
+        }
+
+        private readonly LedgerClient _Ledger;
+        public LedgerClient Ledger
+        {
+            get
+            {
+                return _Ledger;
+            }
+        }
+        WebSocketTransport _Transport = null;
+        public HardwareWalletService(System.Net.WebSockets.WebSocket ledgerWallet)
+        {
+            if (ledgerWallet == null)
+                throw new ArgumentNullException(nameof(ledgerWallet));
+            _Transport = new WebSocketTransport(ledgerWallet);
+            _Ledger = new LedgerClient(_Transport);
+        }
+
+        public async Task<LedgerTestResult> Test()
+        {
+            var version = await _Ledger.GetFirmwareVersionAsync();
+            return new LedgerTestResult() { Success = true };
+        }
+
+        public async Task<GetXPubResult> GetExtPubKey(BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+
+            var pubkey = await GetExtPubKey(_Ledger, network, new KeyPath("49'").Derive(network.CoinType).Derive(0, true), false);
+            var derivation = new DerivationStrategyFactory(network.NBitcoinNetwork).CreateDirectDerivationStrategy(pubkey, new DerivationStrategyOptions()
+            {
+                P2SH = true,
+                Legacy = false
+            });
+            return new GetXPubResult() { ExtPubKey = derivation.ToString() };
+        }
+
+        private static async Task<BitcoinExtPubKey> GetExtPubKey(LedgerClient ledger, BTCPayNetwork network, KeyPath account, bool onlyChaincode)
+        {
+            try
+            {
+                var pubKey = await ledger.GetWalletPubKeyAsync(account);
+                if (pubKey.Address.Network != network.NBitcoinNetwork)
+                {
+                    if (network.DefaultSettings.ChainType == NBXplorer.ChainType.Main)
+                        throw new Exception($"The opened ledger app should be for {network.NBitcoinNetwork.Name}, not for {pubKey.Address.Network}");
+                }
+                var fingerprint = onlyChaincode ? new byte[4] : (await ledger.GetWalletPubKeyAsync(account.Parent)).UncompressedPublicKey.Compress().Hash.ToBytes().Take(4).ToArray();
+                var extpubkey = new ExtPubKey(pubKey.UncompressedPublicKey.Compress(), pubKey.ChainCode, (byte)account.Indexes.Length, fingerprint, account.Indexes.Last()).GetWif(network.NBitcoinNetwork);
+                return extpubkey;
+            }
+            catch (FormatException)
+            {
+                throw new HardwareWalletException("Unsupported ledger app");
+            }
+        }
+
+        public async Task<bool> SupportDerivation(BTCPayNetwork network, DirectDerivationStrategy strategy)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(Network));
+            if (strategy == null)
+                throw new ArgumentNullException(nameof(strategy));
+            return await GetKeyPath(_Ledger, network, strategy) != null;
+        }
+
+        private static async Task<KeyPath> GetKeyPath(LedgerClient ledger, BTCPayNetwork network, DirectDerivationStrategy directStrategy)
+        {
+            KeyPath foundKeyPath = null;
+            foreach (var account in
+                                  new[] { new KeyPath("49'"), new KeyPath("44'") }
+                                  .Select(purpose => purpose.Derive(network.CoinType))
+                                  .SelectMany(coinType => Enumerable.Range(0, 5).Select(i => coinType.Derive(i, true))))
+            {
+                try
+                {
+                    var extpubkey = await GetExtPubKey(ledger, network, account, true);
+                    if (directStrategy.Root.PubKey == extpubkey.ExtPubKey.PubKey)
+                    {
+                        foundKeyPath = account;
+                        break;
+                    }
+                }
+                catch (FormatException)
+                {
+                    throw new Exception($"The opened ledger app does not support {network.NBitcoinNetwork.Name}");
+                }
+            }
+
+            return foundKeyPath;
+        }
+
+        public async Task<Transaction> SendToAddress(DirectDerivationStrategy strategy, 
+                                                             Coin[] coins, BTCPayNetwork network, 
+                                                             (IDestination destination, Money amount, bool substractFees)[] send, 
+                                                             FeeRate feeRate, 
+                                                             IDestination changeAddress,
+                                                             Dictionary<Script, KeyPath> keypaths = null)
+        {
+            if (strategy == null)
+                throw new ArgumentNullException(nameof(strategy));
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            if (feeRate == null)
+                throw new ArgumentNullException(nameof(feeRate));
+            if (changeAddress == null)
+                throw new ArgumentNullException(nameof(changeAddress));
+            if (keypaths == null)
+                throw new ArgumentNullException(nameof(keypaths));
+            if (feeRate.FeePerK <= Money.Zero)
+            {
+                throw new ArgumentOutOfRangeException(nameof(feeRate), "The fee rate should be above zero");
+            }
+
+            foreach (var element in send)
+            {
+                if (element.destination == null)
+                    throw new ArgumentNullException(nameof(element.destination));
+                if (element.amount == null)
+                    throw new ArgumentNullException(nameof(element.amount));
+                if (element.amount <= Money.Zero)
+                    throw new ArgumentOutOfRangeException(nameof(element.amount), "The amount should be above zero");
+            }
+
+            var foundKeyPath = await GetKeyPath(Ledger, network, strategy);
+
+            if (foundKeyPath == null)
+            {
+                throw new HardwareWalletException($"This store is not configured to use this ledger");
+            }
+
+            TransactionBuilder builder = new TransactionBuilder();
+            builder.AddCoins(coins);
+
+            foreach (var element in send)
+            {
+                builder.Send(element.destination, element.amount);
+                if (element.substractFees)
+                    builder.SubtractFees();
+            }
+            builder.SetChange(changeAddress);
+            builder.SendEstimatedFees(feeRate);
+            builder.Shuffle();
+            var unsigned = builder.BuildTransaction(false);
+
+            var hasChange = unsigned.Outputs.Count == 2;
+            var usedCoins = builder.FindSpentCoins(unsigned);
+            _Transport.Timeout = TimeSpan.FromMinutes(5);
+            var fullySigned = await Ledger.SignTransactionAsync(
+                usedCoins.Select(c => new SignatureRequest
+                {
+                    InputCoin = c,
+                    KeyPath = foundKeyPath.Derive(keypaths[c.TxOut.ScriptPubKey]),
+                    PubKey = strategy.Root.Derive(keypaths[c.TxOut.ScriptPubKey]).PubKey
+                }).ToArray(),
+                unsigned,
+                hasChange ? foundKeyPath.Derive(keypaths[changeAddress.ScriptPubKey]) : null);
+            return fullySigned;
+        }
+    }
+
+    public class LedgerTestResult
+    {
+        public bool Success { get; set; }
+        public string Error { get; set; }
+    }
+
+    public class GetXPubResult
+    {
+        public string ExtPubKey { get; set; }
+    }
+}

BTCPayServer/Services/Wallets/BTCPayWallet.cs

@@ -117,13 +117,13 @@ namespace BTCPayServer.Services.Wallets
             return Task.WhenAll(tasks);
         }
 
-        public async Task<(Coin[], Dictionary<OutPoint, KeyPath>)> GetUnspentCoins(DerivationStrategyBase derivationStrategy, CancellationToken cancellation = default(CancellationToken))
+        public async Task<(Coin[], Dictionary<Script, KeyPath>)> GetUnspentCoins(DerivationStrategyBase derivationStrategy, CancellationToken cancellation = default(CancellationToken))
         {
             var changes = await _Client.GetUTXOsAsync(derivationStrategy, null, false, cancellation).ConfigureAwait(false);
-            var keyPaths = new Dictionary<OutPoint, KeyPath>();
+            var keyPaths = new Dictionary<Script, KeyPath>();
             foreach (var coin in changes.GetUnspentUTXOs())
             {
-                keyPaths.TryAdd(coin.Outpoint, coin.KeyPath);
+                keyPaths.TryAdd(coin.ScriptPubKey, coin.KeyPath);
             }
             return (changes.GetUnspentCoins(), keyPaths);
         }

BTCPayServer/Views/Stores/AddDerivationScheme.cshtml

@@ -16,100 +16,101 @@
     <div class="col-md-8">
         <form method="post">
             @if(!Model.Confirmation)
-            {
-                <div class="form-group">
-                    <h5>Derivation Scheme</h5>
-                    <span>The DerivationScheme represents the destination of the funds received by your invoice. It is generated by your wallet software. Please, verify that you are generating the right addresses by clicking on 'Check ExtPubKey'</span>
-                </div>
-                <div class="form-group">
-                    <label asp-for="CryptoCurrency"></label>
-                    <select asp-for="CryptoCurrency" asp-items="Model.CryptoCurrencies" class="form-control"></select>
-                </div>
+    {
+        <div class="form-group">
+            <h5>Derivation Scheme</h5>
+            <span>The DerivationScheme represents the destination of the funds received by your invoice. It is generated by your wallet software. Please, verify that you are generating the right addresses by clicking on 'Check ExtPubKey'</span>
+        </div>
+        <div class="form-group">
+            <label asp-for="CryptoCurrency"></label>
+            <select asp-for="CryptoCurrency" asp-items="Model.CryptoCurrencies" class="form-control"></select>
+        </div>
 
-                <div class="form-group">
-                    <label asp-for="DerivationScheme"></label>
-                    <input asp-for="DerivationScheme" class="form-control" />
-                    <span asp-validation-for="DerivationScheme" class="text-danger"></span>
-                    <p id="no-ledger-info" class="form-text text-muted">
-                        If you own a ledger wallet use chrome, open the app activates the <a href="https://support.ledgerwallet.com/hc/en-us/articles/115005198565-What-is-the-Browser-support-option-made-for-">Browser support</a>, and refresh this page.
-                    </p>
-                    <p id="ledger-info" class="form-text text-muted" style="display: none;">
-                        <span>A ledger wallet is detected, please use our <a id="ledger-info-recommended" href="#">recommended choice</a></span>
-                    </p>
-                </div>
-                <div class="form-group">
-                    <label asp-for="DerivationSchemeFormat"></label>
-                    <select asp-for="DerivationSchemeFormat" asp-items="Model.DerivationSchemeFormats" class="form-control"></select>
-                </div>
-                <div class="form-group">
-                    <span>BTCPay format memo</span>
-                    <table class="table">
-                        <thead class="thead-inverse">
-                            <tr>
-                                <th>Address type</th>
-                                <th>Example</th>
-                            </tr>
-                        </thead>
-                        <tbody>
-                            <tr>
-                                <td>P2WPKH</td>
-                                <td>xpub</td>
-                            </tr>
-                            <tr>
-                                <td>P2SH-P2WPKH</td>
-                                <td>xpub-[p2sh]</td>
-                            </tr>
-                            <tr>
-                                <td>P2PKH</td>
-                                <td>xpub-[legacy]</td>
-                            </tr>
-                            <tr>
-                                <td>Multi-sig P2WSH</td>
-                                <td>2-of-xpub1-xpub2</td>
-                            </tr>
-                            <tr>
-                                <td>Multi-sig P2SH-P2WSH</td>
-                                <td>2-of-xpub1-xpub2-[p2sh]</td>
-                            </tr>
-                            <tr>
-                                <td>Multi-sig P2SH</td>
-                                <td>2-of-xpub1-xpub2-[legacy]</td>
-                            </tr>
-                        </tbody>
-                    </table>
-                </div>
-                <button name="command" type="submit" class="btn btn-info">Continue</button>
-            }
-            else
+        <div class="form-group">
+            <label asp-for="DerivationScheme"></label>
+            <input asp-for="DerivationScheme" class="form-control" />
+            <span asp-validation-for="DerivationScheme" class="text-danger"></span>
+            <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, activate the <a href="https://support.ledgerwallet.com/hc/en-us/articles/115005198565-What-is-the-Browser-support-option-made-for-">Browser support</a>, and refresh this page.
+            </p>
+            <p id="ledger-info" class="form-text text-muted" style="display: none;">
+                <span>A ledger wallet is detected, please use our <a id="ledger-info-recommended" href="#">recommended choice</a></span>
+            </p>
+        </div>
+        <div class="form-group">
+            <label asp-for="DerivationSchemeFormat"></label>
+            <select asp-for="DerivationSchemeFormat" asp-items="Model.DerivationSchemeFormats" class="form-control"></select>
+        </div>
+        <div class="form-group">
+            <span>BTCPay format memo</span>
+            <table class="table">
+                <thead class="thead-inverse">
+                    <tr>
+                        <th>Address type</th>
+                        <th>Example</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>P2WPKH</td>
+                        <td>xpub</td>
+                    </tr>
+                    <tr>
+                        <td>P2SH-P2WPKH</td>
+                        <td>xpub-[p2sh]</td>
+                    </tr>
+                    <tr>
+                        <td>P2PKH</td>
+                        <td>xpub-[legacy]</td>
+                    </tr>
+                    <tr>
+                        <td>Multi-sig P2WSH</td>
+                        <td>2-of-xpub1-xpub2</td>
+                    </tr>
+                    <tr>
+                        <td>Multi-sig P2SH-P2WSH</td>
+                        <td>2-of-xpub1-xpub2-[p2sh]</td>
+                    </tr>
+                    <tr>
+                        <td>Multi-sig P2SH</td>
+                        <td>2-of-xpub1-xpub2-[legacy]</td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+        <button name="command" type="submit" class="btn btn-info">Continue</button>
+}
+else
+{
+        <div class="form-group">
+            <h5>Confirm the addresses (@Model.CryptoCurrency)</h5>
+            <span>Please check that your @Model.CryptoCurrency wallet is generating the same addresses as below.</span>
+        </div>
+        <input type="hidden" asp-for="CryptoCurrency" />
+        <input type="hidden" asp-for="Confirmation" />
+        <input type="hidden" asp-for="DerivationScheme" />
+        <input type="hidden" asp-for="DerivationSchemeFormat" />
+        <div class="form-group">
+            <table class="table">
+                <thead class="thead-inverse">
+                    <tr>
+                        <th>Key path</th>
+                        <th>Address</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    @foreach(var sample in Model.AddressSamples)
             {
-                <div class="form-group">
-                    <h5>Confirm the addresses (@Model.CryptoCurrency)</h5>
-                    <span>Please check that your @Model.CryptoCurrency wallet is generating the same addresses as below.</span>
-                </div>
-                <input type="hidden" asp-for="CryptoCurrency" />
-                <input type="hidden" asp-for="Confirmation" />
-                <input type="hidden" asp-for="DerivationScheme" />
-                <div class="form-group">
-                    <table class="table">
-                        <thead class="thead-inverse">
-                            <tr>
-                                <th>Key path</th>
-                                <th>Address</th>
-                            </tr>
-                        </thead>
-                        <tbody>
-                            @foreach(var sample in Model.AddressSamples)
-                            {
-                                <tr>
-                                    <td>@sample.KeyPath</td>
-                                    <td>@sample.Address</td>
-                                </tr>
-                            }
-                        </tbody>
-                    </table>
-                </div>
-                <button name="command" type="submit" class="btn btn-success">Confirm</button>
-            }
+                <tr>
+                    <td>@sample.KeyPath</td>
+                    <td>@sample.Address</td>
+                </tr>
+    }
+                </tbody>
+            </table>
+        </div>
+        <button name="command" type="submit" class="btn btn-success">Confirm</button>
+}
         </form>
     </div>
 </div>

BTCPayServer/Views/Stores/Wallet.cshtml

@@ -54,7 +54,7 @@
             <input id="fee-textbox" name="FeeRate" class="form-control" type="text" />
             <span id="FeeRate-Error" class="text-danger"></span>
             <p class="form-text text-muted crypto-info" style="display: none;">
-                The recommended value is <a id="crypto-fee-link" href="#"><span id="crypto-fee"></span></a> satoshi per bytes.
+                The recommended value is <a id="crypto-fee-link" href="#"><span id="crypto-fee"></span></a> satoshi per byte.
             </p>
         </div>
         <div class="form-group">

BTCPayServer/wwwroot/js/StoreAddDerivationScheme.js

@@ -8,8 +8,10 @@
     }
 
     function Write(prefix, type, message) {
-
-        
+        if (type === "error") {
+            $("#no-ledger-info").css("display", "block");
+            $("#ledger-in   fo").css("display", "none");
+        }
     }
 
     $("#ledger-info-recommended").on("click", function (elem) {
@@ -20,7 +22,7 @@
     });
 
     $("#CryptoCurrency").on("change", function (elem) {
-        $("#no-ledger-info").css("display", "block");
+        $("#no-ledger-info").css("display", "none");
         $("#ledger-info").css("display", "none");
         updateInfo();
     });
@@ -32,6 +34,8 @@
         bridge.sendCommand("getxpub", "cryptoCode=" + cryptoCode)
             .catch(function (reason) { Write('check', 'error', reason); })
             .then(function (result) {
+                if (!result)
+                    return;
                 if (result.error) {
                     Write('check', 'error', result.error);
                     return;
@@ -51,9 +55,15 @@
                 Write('hw', 'error', 'U2F or Websocket are not supported by this browser');
             }
             else {
-                bridge.sendCommand('test')
-                    .catch(function (reason) { Write('hw', 'error', reason); })
+                bridge.sendCommand('test', null, 5)
+                    .catch(function (reason) {
+                        if (reason.message === "Sign failed")
+                            reason = "Have you forgot to activate browser support in your ledger app?";
+                        Write('hw', 'error', reason);
+                    })
                     .then(function (result) {
+                        if (!result)
+                            return;
                         if (result.error) {
                             Write('hw', 'error', result.error);
                         } else {

BTCPayServer/wwwroot/js/StoreWallet.js

@@ -1,6 +1,8 @@
 $(function () {
     var ledgerDetected = false;
     var bridge = new ledgerwebsocket.LedgerWebSocketBridge(srvModel.serverUrl + "ws/ledger");
+    var recommendedFees = "";
+    var recommendedBalance = "";
 
     function WriteAlert(type, message) {
         $(".alert").removeClass("alert-danger");
@@ -25,6 +27,15 @@
     $("#sendform").on("submit", function (elem) {
         elem.preventDefault();
 
+        if ($("#amount-textbox").val() === "") {
+            $("#amount-textbox").val(recommendedBalance);
+            $("#substract-checkbox").prop("checked", true);
+        }
+
+        if ($("#fee-textbox").val() === "") {
+            $("#fee-textbox").val(recommendedFees);
+        }
+
         var args = "";
         args += "cryptoCode=" + $("#cryptoCurrencies").val();
         args += "&destination=" + $("#destination-textbox").val();
@@ -45,6 +56,8 @@
                 confirmButton.removeClass("disabled");
             })
             .then(function (result) {
+                if (!result)
+                    return;
                 confirmButton.prop("disabled", false);
                 confirmButton.removeClass("disabled");
                 if (result.error) {
@@ -84,6 +97,8 @@
         bridge.sendCommand("getinfo", "cryptoCode=" + cryptoCode)
             .catch(function (reason) { Write('check', 'error', reason); })
             .then(function (result) {
+                if (!result)
+                    return;
                 if (result.error) {
                     Write('check', 'error', result.error);
                     return;
@@ -91,6 +106,8 @@
                 else {
                     Write('check', 'success', 'This store is configured to use your ledger');
                     $(".crypto-info").css("display", "block");
+                    recommendedFees = result.recommendedSatoshiPerByte;
+                    recommendedBalance = result.balance;
                     $("#crypto-fee").text(result.recommendedSatoshiPerByte);
                     $("#crypto-balance").text(result.balance);
                     $("#crypto-code").text(cryptoCode);
@@ -104,9 +121,16 @@
                 Write('hw', 'error', 'U2F or Websocket are not supported by this browser');
             }
             else {
-                bridge.sendCommand('test')
-                    .catch(function (reason) { Write('hw', 'error', reason); })
+                bridge.sendCommand('test', null, 5)
+                    .catch(function (reason)
+                    {
+                        if (reason.message === "Sign failed")
+                            reason = "Have you forgot to activate browser support in your ledger app?";
+                        Write('hw', 'error', reason);
+                    })
                     .then(function (result) {
+                        if (!result)
+                            return;
                         if (result.error) {
                             Write('hw', 'error', result.error);
                         } else {