Do not show cheatmode in release, fix warnigns

* Checkout v2: Play sound when invoice is paid

Closes #5085.

* Refactoring: Use low-level audio API to play the sound

Allows to play the sound regardless of browser permissions.

* Add audio file detection

* Use model state for file upload errors

* Add default sound and customizing option

* Fix mp3 detection

* Add sounds

* Update defaults

* Add nfcread and error sounds

* Improve label wording

* Replace sound

---------

Co-authored-by: nicolas.dorier <nicolas.dorier@gmail.com>

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,14 @@
 blank_issues_enabled: true
 contact_links:
-  - name: 🚀 Discussions
-    url: https://github.com/btcpayserver/btcpayserver/discussions
-    about: Technical discussions, questions and feature requests
+  - name: 💡 Request a feature
+    url: https://github.com/btcpayserver/btcpayserver/discussions/categories/ideas-feature-requests
+    about: Submit a feature request or vote on ideas posted by others. Features with most upvotes become roadmap candidates
+  - name: 🧑‍💻 Ask a technical question
+    url: https://github.com/btcpayserver/btcpayserver/discussions/new?category=technical-support
+    about: If you're experiencing a technical problem post it to our community support forum
+  - name: 🔌 Report a problem with a plugin
+    url: https://github.com/btcpayserver/btcpayserver/discussions/new?category=plugins-integrations
+    about: Experiencing a problem with a third-party plugin? Post it here and we will tag their developers to assist
   - name: 📝 Official Documentation
     url: https://docs.btcpayserver.org
     about: Check our documentation for answers to common questions

.github/codeql/codeql-config.yml

@@ -0,0 +1,2 @@
+paths-ignore:
+  - 'BTCPayServer/wwwroot/vendor/**/*.js'

.github/workflows/codeql.yml

@@ -0,0 +1,80 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+# Allow running tests manually. Usefull if scan failure, or need to rescan before next scheduled date.
+  workflow_dispatch:
+# We scan only on a schedule for now, can uncomment the following to scan on commit or PR merge later on if deemed appropriate.
+  # push:
+  #  branches: [ "master" ]
+  # pull_request:
+  #   branches: [ "master" ]
+  schedule:
+  # Scan every Monday 06:00 UTC.
+    - cron: '0 6 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript', 'csharp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Use only 'java' to analyze code written in Java, Kotlin or both
+        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        config-file: ./.github/codeql/codeql-config.yml
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #     echo "Run, Build Application using script"
+    #     ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:${{matrix.language}}"

.run/Pack Test Extension.run.xml

@@ -1,21 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Pack Test Plugin" type="DotNetProject" factoryName=".NET Project" singleton="false">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/BTCPayServer.PluginPacker/bin/Debug/netcoreapp3.1/BTCPayServer.PluginPacker.dll" />
-    <option name="PROGRAM_PARAMETERS" value="../../../../BTCPayServer.Plugins.Test\bin\Debug\netcoreapp3.1 BTCPayServer.Plugins.Test &quot;../../../../Packed Plugins&quot;" />
-    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/BTCPayServer.PluginPacker/bin/Debug/netcoreapp3.1" />
-    <option name="PASS_PARENT_ENVS" value="1" />
-    <option name="USE_EXTERNAL_CONSOLE" value="0" />
-    <option name="USE_MONO" value="0" />
-    <option name="RUNTIME_ARGUMENTS" value="" />
-    <option name="PROJECT_PATH" value="$PROJECT_DIR$/BTCPayServer.PluginPacker/BTCPayServer.PluginPacker.csproj" />
-    <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
-    <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
-    <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
-    <option name="PROJECT_KIND" value="DotNetCore" />
-    <option name="PROJECT_TFM" value=".NETCoreApp,Version=v3.1" />
-    <method v="2">
-      <option name="Build" default="false" projectName="BTCPayServer.Plugins.Test" projectPath="C:\Git\btcpayserver\Plugins\BTCPayServer.Plugins.Test\BTCPayServer.Plugins.Test.csproj" />
-      <option name="Build" />
-    </method>
-  </configuration>
-</component>

BTCPayServer.Abstractions/Contracts/BaseDbContextFactory.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Data.Common;
 using BTCPayServer.Abstractions.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata;
@@ -21,7 +22,6 @@ namespace BTCPayServer.Abstractions.Contracts
         }
 
         public abstract T CreateContext();
-
         class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
         {
 #pragma warning disable EF1001 // Internal EF Core API usage.

BTCPayServer.Abstractions/Contracts/IPluginHookService.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading.Tasks;
 
 namespace BTCPayServer.Abstractions.Contracts
@@ -6,5 +7,8 @@ namespace BTCPayServer.Abstractions.Contracts
     {
         Task ApplyAction(string hook, object args);
         Task<object> ApplyFilter(string hook, object args);
+
+        event EventHandler<(string hook, object args)> ActionInvoked;
+        event EventHandler<(string hook, object args)> FilterInvoked;
     }
 }

BTCPayServer.Abstractions/Custodians/Client/Exception/AssetBalancesUnavailableException.cs

@@ -5,4 +5,8 @@ public class AssetBalancesUnavailableException : CustodianApiException
     public AssetBalancesUnavailableException(System.Exception e) : base(500, "asset-balances-unavailable", $"Cannot fetch the asset balances: {e.Message}", e)
     {
     }
+
+    public AssetBalancesUnavailableException(string errorMsg) : base(500, "asset-balances-unavailable", $"Cannot fetch the asset balances: {errorMsg}")
+    {
+    }
 }

BTCPayServer.Abstractions/Custodians/Client/Exception/CustodianApiException.cs

@@ -10,7 +10,7 @@ public class CustodianApiException : Exception
         HttpStatus = httpStatus;
         Code = code;
     }
-    
+
     public CustodianApiException(int httpStatus, string code, string message) : this(httpStatus, code, message, null)
     {
     }

BTCPayServer.Abstractions/Custodians/Client/SimulateWithdrawalResult.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using BTCPayServer.Client.Models;
+using BTCPayServer.JsonConverters;
+
+namespace BTCPayServer.Abstractions.Custodians.Client;
+
+public class SimulateWithdrawalResult
+{
+    public string PaymentMethod { get; }
+    public string Asset { get; }
+    public decimal MinQty { get; }
+    public decimal MaxQty { get; }
+
+    public List<LedgerEntryData> LedgerEntries { get; }
+
+    // Fee can be NULL if unknown.
+    public decimal? Fee { get; }
+
+    public SimulateWithdrawalResult(string paymentMethod, string asset, List<LedgerEntryData> ledgerEntries,
+        decimal minQty, decimal maxQty)
+    {
+        PaymentMethod = paymentMethod;
+        Asset = asset;
+        LedgerEntries = ledgerEntries;
+        MinQty = minQty;
+        MaxQty = maxQty;
+    }
+}

BTCPayServer.Abstractions/Custodians/ICanWithdraw.cs

@@ -5,9 +5,14 @@ using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Abstractions.Custodians;
 
+/// <summary>
+/// Interface for custodians that can move funds to the store wallet.
+/// </summary>
 public interface ICanWithdraw
 {
-    public Task<WithdrawResult> WithdrawAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken);
+    public Task<WithdrawResult> WithdrawToStoreWalletAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken);
+
+    public Task<SimulateWithdrawalResult> SimulateWithdrawalAsync(string paymentMethod, decimal qty, JObject config, CancellationToken cancellationToken);
 
     public Task<WithdrawResult> GetWithdrawalInfoAsync(string paymentMethod, string withdrawalId, JObject config, CancellationToken cancellationToken);
 

BTCPayServer.Abstractions/Custodians/ICustodian.cs

@@ -1,3 +1,4 @@
+#nullable enable
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,7 +21,6 @@ public interface ICustodian
      */
     Task<Dictionary<string, decimal>> GetAssetBalancesAsync(JObject config, CancellationToken cancellationToken);
 
-    public Task<Form.Form> GetConfigForm(JObject config, string locale,
-        CancellationToken cancellationToken = default);
+    public Task<Form.Form> GetConfigForm(JObject config, CancellationToken cancellationToken = default);
 
 }

BTCPayServer.Abstractions/Extensions/GreenfieldExtensions.cs

@@ -7,6 +7,10 @@ namespace BTCPayServer.Abstractions.Extensions;
 
 public static class GreenfieldExtensions
 {
+    public static IActionResult UserNotFound(this ControllerBase ctrl)
+    {
+        return ctrl.CreateAPIError(404, "user-not-found", "The user was not found");
+    }
     public static IActionResult CreateValidationError(this ControllerBase controller, ModelStateDictionary modelState)
     {
         return controller.UnprocessableEntity(modelState.ToGreenfieldValidationError());

BTCPayServer.Abstractions/Form/Field.cs

@@ -28,7 +28,7 @@ public class Field
 
     public bool Constant;
 
-    // HTML5 compatible type string like "text", "textarea", "email", "password", etc. Each type is a class and may contain more fields (i.e. "select" would have options).
+    // HTML5 compatible type string like "text", "textarea", "email", "password", etc.
     public string Type;
 
     public static Field CreateFieldset()
@@ -52,10 +52,10 @@ public class Field
     public string HelpText;
 
     [JsonExtensionData] public IDictionary<string, JToken> AdditionalData { get; set; }
-    public List<Field> Fields { get; set; } = new ();
+    public List<Field> Fields { get; set; } = new();
 
     // The field is considered "valid" if there are no validation errors
-    public List<string> ValidationErrors = new ();
+    public List<string> ValidationErrors = new();
 
     public virtual bool IsValid()
     {

BTCPayServer.Abstractions/Form/Form.cs

@@ -32,6 +32,8 @@ public class Form
     // Are all the fields valid in the form?
     public bool IsValid()
     {
+        if (TopMessages?.Any(t => t.Type == AlertMessage.AlertMessageType.Danger) is true)
+            return false;
         return Fields.Select(f => f.IsValid()).All(o => o);
     }
 
@@ -50,7 +52,7 @@ public class Form
         HashSet<string> nameReturned = new();
         foreach (var f in GetAllFieldsCore(new List<string>(), Fields))
         {
-            var fullName = string.Join('_', f.Path);
+            var fullName = string.Join('_', f.Path.Where(s => !string.IsNullOrEmpty(s)));
             if (!nameReturned.Add(fullName))
                 continue;
             yield return (fullName, f.Path, f.Field);
@@ -63,11 +65,10 @@ public class Form
         HashSet<string> nameReturned = new();
         foreach (var f in GetAllFieldsCore(new List<string>(), Fields))
         {
-            var fullName = string.Join('_', f.Path);
+            var fullName = string.Join('_', f.Path.Where(s => !string.IsNullOrEmpty(s)));
             if (!nameReturned.Add(fullName))
             {
                 errors.Add($"Form contains duplicate field names '{fullName}'");
-                continue;
             }
         }
         return errors.Count == 0;
@@ -84,15 +85,10 @@ public class Form
                 thisPath.Add(field.Name);
                 yield return (thisPath, field);
             }
-
-            foreach (var child in field.Fields)
+            foreach (var descendant in GetAllFieldsCore(thisPath, field.Fields))
             {
-                if (field.Constant)
-                    child.Constant = true;
-                foreach (var descendant in GetAllFieldsCore(thisPath, field.Fields))
-                {
-                    yield return descendant;
-                }
+                descendant.Field.Constant = field.Constant || descendant.Field.Constant;
+                yield return descendant;
             }
         }
     }
@@ -128,32 +124,12 @@ public class Form
             }
             else if (prop.Value.Type == JTokenType.String)
             {
-                var fullname = String.Join('_', propPath);
-                if (fields.TryGetValue(fullname, out var f) && !f.Constant)
+                var fullName = string.Join('_', propPath.Where(s => !string.IsNullOrEmpty(s)));
+                if (fields.TryGetValue(fullName, out var f) && !f.Constant)
                     f.Value = prop.Value.Value<string>();
             }
         }
     }
 
-    public JObject GetValues()
-    {
-        var r = new JObject();
-        foreach (var f in GetAllFields())
-        {
-            var node = r;
-            for (int i = 0; i < f.Path.Count - 1; i++)
-            {
-                var p = f.Path[i];
-                var child = node[p] as JObject;
-                if (child is null)
-                {
-                    child = new JObject();
-                    node[p] = child;
-                }
-                node = child;
-            }
-            node[f.Field.Name] = f.Field.Value;
-        }
-        return r;
-    }
+
 }

BTCPayServer.Abstractions/Security/ContentSecurityPolicies.cs

@@ -114,6 +114,11 @@ namespace BTCPayServer.Security
             _Policies.Add(policy);
         }
 
+        public void UnsafeEval()
+        {
+            Add("script-src", "'unsafe-eval'");
+        }
+
         public IEnumerable<ConsentSecurityPolicy> Rules => _Policies;
         public bool HasRules => _Policies.Count != 0;
 

BTCPayServer.Abstractions/TagHelpers/PermissionTagHelper.cs

@@ -6,31 +6,33 @@ using Microsoft.Extensions.Logging;
 
 namespace BTCPayServer.Abstractions.TagHelpers;
 
-[HtmlTargetElement(Attributes = nameof(Permission))]
+[HtmlTargetElement(Attributes = "[permission]")]
+[HtmlTargetElement(Attributes = "[not-permission]"  )]
 public class PermissionTagHelper : TagHelper
 {
     private readonly IAuthorizationService _authorizationService;
     private readonly IHttpContextAccessor _httpContextAccessor;
-    private readonly ILogger<PermissionTagHelper> _logger;
 
-    public PermissionTagHelper(IAuthorizationService authorizationService, IHttpContextAccessor httpContextAccessor, ILogger<PermissionTagHelper> logger)
+    public PermissionTagHelper(IAuthorizationService authorizationService, IHttpContextAccessor httpContextAccessor)
     {
         _authorizationService = authorizationService;
         _httpContextAccessor = httpContextAccessor;
-        _logger = logger;
     }
 
     public string Permission { get; set; }
+    public string NotPermission { get; set; }
     public string PermissionResource { get; set; }
+    
 
     public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
     {
-        if (string.IsNullOrEmpty(Permission))
+        if (string.IsNullOrEmpty(Permission) && string.IsNullOrEmpty(NotPermission))
             return;
         if (_httpContextAccessor.HttpContext is null)
             return;
 
-        var key = $"{Permission}_{PermissionResource}";
+        var expectedResult = !string.IsNullOrEmpty(Permission);
+        var key = $"{Permission??NotPermission}_{PermissionResource}";
         if (!_httpContextAccessor.HttpContext.Items.TryGetValue(key, out var o) ||
             o is not AuthorizationResult res)
         {
@@ -39,7 +41,7 @@ public class PermissionTagHelper : TagHelper
                 Permission);
             _httpContextAccessor.HttpContext.Items.Add(key, res);
         }
-        if (!res.Succeeded)
+        if (expectedResult != res.Succeeded)
         {
             output.SuppressOutput();
         }

BTCPayServer.Abstractions/TagHelpers/SVGUse.cs

@@ -23,12 +23,12 @@ public class SVGUse : UrlResolutionTagHelper2
     {
         _fileVersionProvider = fileVersionProvider;
     }
-    
+
     public override void Process(TagHelperContext context, TagHelperOutput output)
     {
         var attr = output.Attributes["href"].Value.ToString();
         var symbolIndex = attr!.IndexOf("#", StringComparison.InvariantCulture);
-        var start = attr.IndexOf("~", StringComparison.InvariantCulture) + 1; 
+        var start = attr.IndexOf("~", StringComparison.InvariantCulture) + 1;
         var length = (symbolIndex != -1 ? symbolIndex : attr.Length) - start;
         var filePath = attr.Substring(start, length);
         if (!string.IsNullOrEmpty(filePath))

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -12,6 +12,8 @@
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <RepositoryUrl>https://github.com/btcpayserver/btcpayserver</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
+        <Configurations>Debug;Release;Altcoins-Debug;Altcoins-Release</Configurations>
+        <Platforms>AnyCPU</Platforms>
     </PropertyGroup>
   <PropertyGroup>
     <Version Condition=" '$(Version)' == '' ">1.7.2</Version>

BTCPayServer.Client/BTCPayServerClient.Apps.cs

@@ -51,7 +51,7 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Get), token);
             return await HandleResponse<AppDataBase>(response);
         }
-        
+
         public virtual async Task<AppDataBase[]> GetAllApps(string storeId, CancellationToken token = default)
         {
             if (storeId == null)

BTCPayServer.Client/BTCPayServerClient.CustodianAccounts.cs

@@ -50,7 +50,7 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public virtual async Task<DepositAddressData> GetDepositAddress(string storeId, string accountId, string paymentMethod, CancellationToken token = default)
+        public virtual async Task<DepositAddressData> GetCustodianAccountDepositAddress(string storeId, string accountId, string paymentMethod, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/addresses/{paymentMethod}"), token);
             return await HandleResponse<DepositAddressData>(response);
@@ -58,7 +58,6 @@ namespace BTCPayServer.Client
 
         public virtual async Task<MarketTradeResponseData> MarketTradeCustodianAccountAsset(string storeId, string accountId, TradeRequestData request, CancellationToken token = default)
         {
-
             //var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/users", null, request, HttpMethod.Post), token);
             //return await HandleResponse<ApplicationUserData>(response);
             var internalRequest = CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/market", null,
@@ -67,13 +66,13 @@ namespace BTCPayServer.Client
             return await HandleResponse<MarketTradeResponseData>(response);
         }
 
-        public virtual async Task<MarketTradeResponseData> GetTradeInfo(string storeId, string accountId, string tradeId, CancellationToken token = default)
+        public virtual async Task<MarketTradeResponseData> GetCustodianAccountTradeInfo(string storeId, string accountId, string tradeId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/{tradeId}", method: HttpMethod.Get), token);
             return await HandleResponse<MarketTradeResponseData>(response);
         }
 
-        public virtual async Task<TradeQuoteResponseData> GetTradeQuote(string storeId, string accountId, string fromAsset, string toAsset, CancellationToken token = default)
+        public virtual async Task<TradeQuoteResponseData> GetCustodianAccountTradeQuote(string storeId, string accountId, string fromAsset, string toAsset, CancellationToken token = default)
         {
             var queryPayload = new Dictionary<string, object>();
             queryPayload.Add("fromAsset", fromAsset);
@@ -82,13 +81,19 @@ namespace BTCPayServer.Client
             return await HandleResponse<TradeQuoteResponseData>(response);
         }
 
-        public virtual async Task<WithdrawalResponseData> CreateWithdrawal(string storeId, string accountId, WithdrawRequestData request, CancellationToken token = default)
+        public virtual async Task<WithdrawalResponseData> CreateCustodianAccountWithdrawal(string storeId, string accountId, WithdrawRequestData request, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals", bodyPayload: request, method: HttpMethod.Post), token);
             return await HandleResponse<WithdrawalResponseData>(response);
         }
 
-        public virtual async Task<WithdrawalResponseData> GetWithdrawalInfo(string storeId, string accountId, string paymentMethod, string withdrawalId, CancellationToken token = default)
+        public virtual async Task<WithdrawalSimulationResponseData> SimulateCustodianAccountWithdrawal(string storeId, string accountId, WithdrawRequestData request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals/simulation", bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<WithdrawalSimulationResponseData>(response);
+        }
+
+        public virtual async Task<WithdrawalResponseData> GetCustodianAccountWithdrawalInfo(string storeId, string accountId, string paymentMethod, string withdrawalId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals/{paymentMethod}/{withdrawalId}", method: HttpMethod.Get), token);
             return await HandleResponse<WithdrawalResponseData>(response);

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -113,7 +113,7 @@ namespace BTCPayServer.Client
                 CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices", queryPayload), token);
             return await HandleResponse<LightningInvoiceData[]>(response);
         }
-        
+
         public virtual async Task<LightningPaymentData[]> GetLightningPayments(string cryptoCode,
             bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
         {

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -115,7 +115,7 @@ namespace BTCPayServer.Client
                 CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", queryPayload), token);
             return await HandleResponse<LightningInvoiceData[]>(response);
         }
-        
+
         public virtual async Task<LightningPaymentData[]> GetLightningPayments(string storeId, string cryptoCode,
             bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
         {

BTCPayServer.Client/BTCPayServerClient.ServerInfo.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
@@ -11,5 +12,11 @@ namespace BTCPayServer.Client
             var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/server/info"), token);
             return await HandleResponse<ServerInfoData>(response);
         }
+        
+        public virtual async Task<List<RoleData>> GetServerRoles(CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/server/roles"), token);
+            return await HandleResponse<List<RoleData>>(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreRatesConfiguration.cs

@@ -54,7 +54,7 @@ namespace BTCPayServer.Client
             CancellationToken token = default)
         {
             using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/rates", 
+                CreateHttpRequest($"api/v1/stores/{storeId}/rates",
                     queryPayload: new Dictionary<string, object>() { { "currencyPair", currencyPair } },
                     method: HttpMethod.Get),
                 token);

BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

@@ -9,6 +9,13 @@ namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
+        public virtual async Task<List<RoleData>> GetStoreRoles(string storeId,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/roles"), token);
+            return await HandleResponse<List<RoleData>>(response);
+        }
+        
         public virtual async Task<IEnumerable<StoreUserData>> GetStoreUsers(string storeId,
             CancellationToken token = default)
         {

BTCPayServer.Client/BTCPayServerClient.cs

@@ -51,7 +51,8 @@ namespace BTCPayServer.Client
             {
                 if (message.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
                 {
-                    var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(await message.Content.ReadAsStringAsync());
+                    var aa = await message.Content.ReadAsStringAsync();
+                    var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(aa);
                     throw new GreenfieldValidationException(err);
                 }
                 if (message.StatusCode == System.Net.HttpStatusCode.Forbidden)

BTCPayServer.Client/JsonConverters/NumericStringJsonConverter.cs

@@ -30,9 +30,9 @@ namespace BTCPayServer.JsonConverters
                 case JTokenType.Integer:
                 case JTokenType.String:
                     if (objectType == typeof(decimal) || objectType == typeof(decimal?))
-                        return decimal.Parse(token.ToString(), CultureInfo.InvariantCulture);
+                        return decimal.Parse(token.ToString(), NumberStyles.Any, CultureInfo.InvariantCulture);
                     if (objectType == typeof(double) || objectType == typeof(double?))
-                        return double.Parse(token.ToString(), CultureInfo.InvariantCulture);
+                        return double.Parse(token.ToString(), NumberStyles.Any, CultureInfo.InvariantCulture);
                     throw new JsonSerializationException("Unexpected object type: " + objectType);
                 case JTokenType.Null when objectType == typeof(decimal?) || objectType == typeof(double?):
                     return null;

BTCPayServer.Client/JsonConverters/TradeQuantityJsonConverter.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Globalization;
+using BTCPayServer.Client.Models;
+using BTCPayServer.Lightning;
+using NBitcoin.JsonConverters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.JsonConverters
+{
+    public class TradeQuantityJsonConverter : JsonConverter<TradeQuantity>
+    {
+        public override TradeQuantity ReadJson(JsonReader reader, Type objectType, TradeQuantity existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            JToken token = JToken.Load(reader);
+            switch (token.Type)
+            {
+                case JTokenType.Float:
+                case JTokenType.Integer:
+                case JTokenType.String:
+                    if (TradeQuantity.TryParse(token.ToString(), out var q))
+                        return q;
+                    break;
+                case JTokenType.Null:
+                    return null;
+            }
+            throw new JsonObjectException("Invalid TradeQuantity, expected string. Expected: \"1.50\" or \"50%\"", reader);
+        }
+
+        public override void WriteJson(JsonWriter writer, TradeQuantity value, JsonSerializer serializer)
+        {
+            if (value is not null)
+                writer.WriteValue(value.ToString());
+        }
+    }
+}

BTCPayServer.Client/Models/CreatePayoutThroughStoreRequest.cs

@@ -1,8 +1,11 @@
 #nullable enable
+using Newtonsoft.Json.Linq;
+
 namespace BTCPayServer.Client.Models;
 
 public class CreatePayoutThroughStoreRequest : CreatePayoutRequest
 {
     public string? PullPaymentId { get; set; }
     public bool? Approved { get; set; }
+    public JObject? Metadata { get; set; }
 }

BTCPayServer.Client/Models/InvoiceData.cs

@@ -86,6 +86,7 @@ namespace BTCPayServer.Client.Models
             public bool? RequiresRefundEmail { get; set; } = null;
             public string DefaultLanguage { get; set; }
             public CheckoutType? CheckoutType { get; set; }
+            public bool? LazyPaymentMethods { get; set; }
         }
     }
     public class InvoiceData : InvoiceDataBase

BTCPayServer.Client/Models/LNURLPayPaymentMethodBaseData.cs

@@ -3,7 +3,6 @@ namespace BTCPayServer.Client.Models
     public class LNURLPayPaymentMethodBaseData
     {
         public bool UseBech32Scheme { get; set; }
-        public bool EnableForStandardInvoices { get; set; }
         public bool LUD12Enabled { get; set; }
 
         public LNURLPayPaymentMethodBaseData()

BTCPayServer.Client/Models/LNURLPayPaymentMethodData.cs

@@ -16,12 +16,11 @@ namespace BTCPayServer.Client.Models
         {
         }
 
-        public LNURLPayPaymentMethodData(string cryptoCode, bool enabled, bool useBech32Scheme, bool enableForStandardInvoices)
+        public LNURLPayPaymentMethodData(string cryptoCode, bool enabled, bool useBech32Scheme)
         {
             Enabled = enabled;
             CryptoCode = cryptoCode;
             UseBech32Scheme = useBech32Scheme;
-            EnableForStandardInvoices = enableForStandardInvoices;
         }
     }
 }

BTCPayServer.Client/Models/LedgerEntryData.cs

@@ -1,3 +1,4 @@
+using BTCPayServer.JsonConverters;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
@@ -6,6 +7,7 @@ namespace BTCPayServer.Client.Models;
 public class LedgerEntryData
 {
     public string Asset { get; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
     public decimal Qty { get; }
 
     [JsonConverter(typeof(StringEnumConverter))]

BTCPayServer.Client/Models/LightningAddressData.cs

@@ -6,5 +6,5 @@ public class LightningAddressData
     public string CurrencyCode { get; set; }
     public decimal? Min { get; set; }
     public decimal? Max { get; set; }
-    
+
 }

BTCPayServer.Client/Models/LightningAutomatedPayoutSettings.cs

@@ -10,4 +10,9 @@ public class LightningAutomatedPayoutSettings
 
     [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
     public TimeSpan IntervalSeconds { get; set; }
+
+    public int? CancelPayoutAfterFailures { get; set; }
+    [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+    public bool  ProcessNewPayoutsInstantly { get; set; }
+    
 }

BTCPayServer.Client/Models/LightningInvoiceData.cs

@@ -16,7 +16,7 @@ namespace BTCPayServer.Client.Models
 
         [JsonProperty("BOLT11")]
         public string BOLT11 { get; set; }
-        
+
         public string PaymentHash { get; set; }
 
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
@@ -24,7 +24,7 @@ namespace BTCPayServer.Client.Models
 
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset? PaidAt { get; set; }
-        
+
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset ExpiresAt { get; set; }
 

BTCPayServer.Client/Models/LightningNetworkPaymentMethodBaseData.cs

@@ -4,7 +4,6 @@ namespace BTCPayServer.Client.Models
     {
 
         public string ConnectionString { get; set; }
-        public bool DisableBOLT11PaymentOption { get; set; }
         public LightningNetworkPaymentMethodBaseData()
         {
 

BTCPayServer.Client/Models/LightningNetworkPaymentMethodData.cs

@@ -16,13 +16,12 @@ namespace BTCPayServer.Client.Models
         {
         }
 
-        public LightningNetworkPaymentMethodData(string cryptoCode, string connectionString, bool enabled, string paymentMethod, bool disableBOLT11PaymentOption)
+        public LightningNetworkPaymentMethodData(string cryptoCode, string connectionString, bool enabled, string paymentMethod)
         {
             Enabled = enabled;
             CryptoCode = cryptoCode;
             ConnectionString = connectionString;
             PaymentMethod = paymentMethod;
-            DisableBOLT11PaymentOption = disableBOLT11PaymentOption;
         }
 
         public string PaymentMethod { get; set; }

BTCPayServer.Client/Models/OnChainAutomatedPayoutSettings.cs

@@ -12,4 +12,8 @@ public class OnChainAutomatedPayoutSettings
     public TimeSpan IntervalSeconds { get; set; }
 
     public int? FeeBlockTarget { get; set; }
+    [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+    public decimal Threshold { get; set; }
+    [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+    public bool  ProcessNewPayoutsInstantly { get; set; }
 }

BTCPayServer.Client/Models/PayoutData.cs

@@ -31,5 +31,6 @@ namespace BTCPayServer.Client.Models
         public PayoutState State { get; set; }
         public int Revision { get; set; }
         public JObject PaymentProof { get; set; }
+        public JObject Metadata { get; set; }
     }
 }

BTCPayServer.Client/Models/RefundInvoiceRequest.cs

@@ -9,6 +9,7 @@ namespace BTCPayServer.Client.Models
     {
         RateThen,
         CurrentRate,
+        OverpaidAmount,
         Fiat,
         Custom
     }
@@ -18,8 +19,13 @@ namespace BTCPayServer.Client.Models
         public string? Name { get; set; } = null;
         public string? PaymentMethod { get; set; }
         public string? Description { get; set; } = null;
+        
         [JsonConverter(typeof(StringEnumConverter))]
         public RefundVariant? RefundVariant { get; set; }
+        
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal SubtractPercentage { get; set; }
+        
         [JsonConverter(typeof(NumericStringJsonConverter))]
         public decimal? CustomAmount { get; set; }
         public string? CustomCurrency { get; set; }

BTCPayServer.Client/Models/StoreBaseData.cs

@@ -16,6 +16,8 @@ namespace BTCPayServer.Client.Models
 
         public string Website { get; set; }
 
+        public string SupportUrl { get; set; }
+
         [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public TimeSpan InvoiceExpiration { get; set; } = TimeSpan.FromMinutes(15);

BTCPayServer.Client/Models/StoreData.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 namespace BTCPayServer.Client.Models
 {
     public class StoreData : StoreBaseData
@@ -17,4 +19,12 @@ namespace BTCPayServer.Client.Models
 
         public string Role { get; set; }
     }
+
+    public class RoleData
+    {
+        public string Id { get; set; }
+        public List<string> Permissions { get; set; }
+        public string Role { get; set; }
+        public bool IsServerRole { get; set; }
+    }
 }

BTCPayServer.Client/Models/StoreReportRequest.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models;
+
+public class StoreReportRequest
+{
+    public string ViewName { get; set; }
+    public TimePeriod TimePeriod { get; set; }
+}
+public class StoreReportResponse
+{
+    public class Field
+    {
+        public Field()
+        {
+
+        }
+        public Field(string name, string type)
+        {
+            Name = name;
+            Type = type;
+        }
+        public string Name { get; set; }
+        public string Type { get; set; }
+    }
+    public IList<Field> Fields { get; set; } = new List<Field>();
+    public List<JArray> Data { get; set; }
+    public DateTimeOffset From { get; set; }
+    public DateTimeOffset To { get; set; }
+    public List<ChartDefinition> Charts { get; set; }
+
+    public int GetIndex(string fieldName)
+    {
+        return Fields.ToList().FindIndex(f => f.Name == fieldName);
+    }
+}
+
+public class ChartDefinition
+{
+    public string Name { get; set; }
+
+    public List<string> Groups { get; set; } = new List<string>();
+    public List<string> Totals { get; set; } = new List<string>();
+    public bool HasGrandTotal { get; set; }
+    public List<string> Aggregates { get; set; } = new List<string>();
+    public List<string> Filters { get; set; } = new List<string>();
+}
+
+public class TimePeriod
+{
+    [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+    public DateTimeOffset? From { get; set; }
+    [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+    public DateTimeOffset? To { get; set; }
+}

BTCPayServer.Client/Models/StoreReportsResponse.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BTCPayServer.Client.Models
+{
+    public class StoreReportsResponse
+    {
+        public string ViewName { get; set; }
+        public StoreReportResponse.Field[] Fields
+        {
+            get;
+            set;
+        }
+    }
+}

BTCPayServer.Client/Models/TradeQuoteResponseData.cs

@@ -1,8 +1,13 @@
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
 namespace BTCPayServer.Client.Models;
 
 public class TradeQuoteResponseData
 {
+    [JsonConverter(typeof(NumericStringJsonConverter))]
     public decimal Bid { get; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
     public decimal Ask { get; }
     public string ToAsset { get; }
     public string FromAsset { get; }

BTCPayServer.Client/Models/TradeRequestData.cs

@@ -1,8 +1,11 @@
+using Newtonsoft.Json;
+
 namespace BTCPayServer.Client.Models;
 
 public class TradeRequestData
 {
     public string FromAsset { set; get; }
     public string ToAsset { set; get; }
-    public string Qty { set; get; }
+    [JsonConverter(typeof(JsonConverters.TradeQuantityJsonConverter))]
+    public TradeQuantity Qty { set; get; }
 }

BTCPayServer.Client/Models/WebhookEvent.cs

@@ -51,6 +51,10 @@ namespace BTCPayServer.Client.Models
         public DateTimeOffset Timestamp { get; set; }
         [JsonExtensionData]
         public IDictionary<string, JToken> AdditionalData { get; set; }
+        public bool IsPruned()
+        {
+            return DeliveryId is null;
+        }
         public T ReadAs<T>()
         {
             var str = JsonConvert.SerializeObject(this, DefaultSerializerSettings);

BTCPayServer.Client/Models/WithdrawRequestData.cs

@@ -1,13 +1,85 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Net.Http.Headers;
+using Newtonsoft.Json;
+
 namespace BTCPayServer.Client.Models;
 
 public class WithdrawRequestData
 {
     public string PaymentMethod { set; get; }
-    public decimal Qty { set; get; }
+    [JsonConverter(typeof(JsonConverters.TradeQuantityJsonConverter))]
+    public TradeQuantity Qty { set; get; }
 
-    public WithdrawRequestData(string paymentMethod, decimal qty)
+    public WithdrawRequestData()
+    {
+
+    }
+
+    public WithdrawRequestData(string paymentMethod, TradeQuantity qty)
     {
         PaymentMethod = paymentMethod;
         Qty = qty;
     }
 }
+
+#nullable enable
+public record TradeQuantity
+{
+    public TradeQuantity(decimal value, ValueType type)
+    {
+        Type = type;
+        Value = value;
+    }
+
+    public enum ValueType
+    {
+        Exact,
+        Percent
+    }
+
+    public ValueType Type { get; }
+    public decimal Value { get; set; }
+
+    public override string ToString()
+    {
+        if (Type == ValueType.Exact)
+            return Value.ToString(CultureInfo.InvariantCulture);
+        else
+            return Value.ToString(CultureInfo.InvariantCulture) + "%";
+    }
+    public static TradeQuantity Parse(string str)
+    {
+        if (!TryParse(str, out var r))
+            throw new FormatException("Invalid TradeQuantity");
+        return r;
+    }
+    public static bool TryParse(string str, [MaybeNullWhen(false)] out TradeQuantity quantity)
+    {
+        if (str is null)
+            throw new ArgumentNullException(nameof(str));
+        quantity = null;
+        str = str.Trim();
+        str = str.Replace(" ", "");
+        if (str.Length == 0)
+            return false;
+        if (str[^1] == '%')
+        {
+            if (!decimal.TryParse(str[..^1], NumberStyles.Any, CultureInfo.InvariantCulture, out var r))
+                return false;
+            if (r < 0.0m)
+                return false;
+            quantity = new TradeQuantity(r, TradeQuantity.ValueType.Percent);
+        }
+        else
+        {
+            if (!decimal.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture, out var r))
+                return false;
+            if (r < 0.0m)
+                return false;
+            quantity = new TradeQuantity(r, TradeQuantity.ValueType.Exact);
+        }
+        return true;
+    }
+}

BTCPayServer.Client/Models/WithdrawalBaseResponseData.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models;
+
+public abstract class WithdrawalBaseResponseData
+{
+    public string Asset { get; }
+    public string PaymentMethod { get; }
+    public List<LedgerEntryData> LedgerEntries { get; }
+    public string AccountId { get; }
+    public string CustodianCode { get; }
+
+    public WithdrawalBaseResponseData(string paymentMethod, string asset, List<LedgerEntryData> ledgerEntries, string accountId,
+        string custodianCode)
+    {
+        PaymentMethod = paymentMethod;
+        Asset = asset;
+        LedgerEntries = ledgerEntries;
+        AccountId = accountId;
+        CustodianCode = custodianCode;
+    }
+}

BTCPayServer.Client/Models/WithdrawalResponseData.cs

@@ -5,18 +5,13 @@ using Newtonsoft.Json.Converters;
 
 namespace BTCPayServer.Client.Models;
 
-public class WithdrawalResponseData
+public class WithdrawalResponseData : WithdrawalBaseResponseData
 {
-    public string Asset { get; }
-    public string PaymentMethod { get; }
-    public List<LedgerEntryData> LedgerEntries { get; }
-    public string WithdrawalId { get; }
-    public string AccountId { get; }
-    public string CustodianCode { get; }
 
     [JsonConverter(typeof(StringEnumConverter))]
     public WithdrawalStatus Status { get; }
 
+    public string WithdrawalId { get; }
     public DateTimeOffset CreatedTime { get; }
 
     public string TransactionId { get; }
@@ -24,14 +19,10 @@ public class WithdrawalResponseData
     public string TargetAddress { get; }
 
     public WithdrawalResponseData(string paymentMethod, string asset, List<LedgerEntryData> ledgerEntries, string withdrawalId, string accountId,
-        string custodianCode, WithdrawalStatus status, DateTimeOffset createdTime, string targetAddress, string transactionId)
+        string custodianCode, WithdrawalStatus status, DateTimeOffset createdTime, string targetAddress, string transactionId) : base(paymentMethod, asset, ledgerEntries, accountId,
+        custodianCode)
     {
-        PaymentMethod = paymentMethod;
-        Asset = asset;
-        LedgerEntries = ledgerEntries;
         WithdrawalId = withdrawalId;
-        AccountId = accountId;
-        CustodianCode = custodianCode;
         TargetAddress = targetAddress;
         TransactionId = transactionId;
         Status = status;

BTCPayServer.Client/Models/WithdrawalSimulationResponseData.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class WithdrawalSimulationResponseData : WithdrawalBaseResponseData
+{
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal? MinQty { get; set; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal? MaxQty { get; set; }
+
+    public WithdrawalSimulationResponseData(string paymentMethod, string asset, string accountId,
+        string custodianCode, List<LedgerEntryData> ledgerEntries, decimal? minQty, decimal? maxQty) : base(paymentMethod,
+        asset, ledgerEntries, accountId, custodianCode)
+    {
+        MinQty = minQty;
+        MaxQty = maxQty;
+    }
+}

BTCPayServer.Client/Permissions.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
+using System.Linq.Expressions;
 
 namespace BTCPayServer.Client
 {
@@ -98,14 +100,45 @@ namespace BTCPayServer.Client
         {
             return policy.StartsWith("btcpay.plugin", StringComparison.OrdinalIgnoreCase);
         }
+        public static bool IsUserPolicy(string policy)
+        {
+            return policy.StartsWith("btcpay.user", StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    public class PermissionSet
+    {
+        public PermissionSet() : this(Array.Empty<Permission>())
+        {
+
+        }
+        public PermissionSet(Permission[] permissions)
+        {
+            Permissions = permissions;
+        }
+
+        public Permission[] Permissions { get; }
+
+        public bool Contains(Permission requestedPermission)
+        {
+            return Permissions.Any(p => p.Contains(requestedPermission));
+        }
+        public bool Contains(string permission, string store)
+        {
+            if (permission is null)
+                throw new ArgumentNullException(nameof(permission));
+            if (store is null)
+                throw new ArgumentNullException(nameof(store));
+            return Contains(Permission.Create(permission, store));
+        }
     }
     public class Permission
     {
         static Permission()
         {
-            Init();
+            PolicyMap = Init();
         }
-        
+
         public static Permission Create(string policy, string scope = null)
         {
             if (TryCreatePermission(policy, scope, out var r))
@@ -121,7 +154,7 @@ namespace BTCPayServer.Client
             policy = policy.Trim().ToLowerInvariant();
             if (!Policies.IsValidPolicy(policy))
                 return false;
-            if (scope != null && !Policies.IsStorePolicy(policy))
+            if (!string.IsNullOrEmpty(scope) && !Policies.IsStorePolicy(policy))
                 return false;
             permission = new Permission(policy, scope);
             return true;
@@ -174,7 +207,7 @@ namespace BTCPayServer.Client
             }
             if (!Policies.IsStorePolicy(subpermission.Policy))
                 return true;
-            return Scope == null || subpermission.Scope == this.Scope;
+            return Scope == null || subpermission.Scope == Scope;
         }
 
         public static IEnumerable<Permission> ToPermissions(string[] permissions)
@@ -199,42 +232,62 @@ namespace BTCPayServer.Client
                 return true;
             if (policy == subpolicy)
                 return true;
-            if (!PolicyMap.TryGetValue(policy, out var subPolicies)) return false;
+            if (!PolicyMap.TryGetValue(policy, out var subPolicies))
+                return false;
             return subPolicies.Contains(subpolicy) || subPolicies.Any(s => ContainsPolicy(s, subpolicy));
         }
 
-        private static Dictionary<string, HashSet<string>> PolicyMap = new();
+        public static ReadOnlyDictionary<string, HashSet<string>> PolicyMap { get; private set; }
+    
 
-        private static void Init()
+        private static ReadOnlyDictionary<string, HashSet<string>> Init()
         {
-            PolicyHasChild(Policies.CanModifyStoreSettings,
+            var policyMap = new Dictionary<string, HashSet<string>>();
+            PolicyHasChild(policyMap, Policies.CanModifyStoreSettings,
                 Policies.CanManageCustodianAccounts,
                 Policies.CanManagePullPayments,
                 Policies.CanModifyInvoices,
                 Policies.CanViewStoreSettings,
                 Policies.CanModifyStoreWebhooks,
-                Policies.CanModifyPaymentRequests);
+                Policies.CanModifyPaymentRequests,
+                Policies.CanUseLightningNodeInStore);
 
-            PolicyHasChild(Policies.CanManageUsers, Policies.CanCreateUser);
-            PolicyHasChild(Policies.CanManagePullPayments, Policies.CanCreatePullPayments );
-            PolicyHasChild(Policies.CanCreatePullPayments, Policies.CanCreateNonApprovedPullPayments );
-            PolicyHasChild(Policies.CanModifyPaymentRequests, Policies.CanViewPaymentRequests );
-            PolicyHasChild(Policies.CanModifyProfile, Policies.CanViewProfile );
-            PolicyHasChild(Policies.CanUseLightningNodeInStore, Policies.CanViewLightningInvoiceInStore, Policies.CanCreateLightningInvoiceInStore );
-            PolicyHasChild(Policies.CanManageNotificationsForUser, Policies.CanViewNotificationsForUser );
-            PolicyHasChild(Policies.CanModifyServerSettings,
+            PolicyHasChild(policyMap,Policies.CanManageUsers, Policies.CanCreateUser);
+            PolicyHasChild(policyMap,Policies.CanManagePullPayments, Policies.CanCreatePullPayments);
+            PolicyHasChild(policyMap,Policies.CanCreatePullPayments, Policies.CanCreateNonApprovedPullPayments);
+            PolicyHasChild(policyMap,Policies.CanModifyPaymentRequests, Policies.CanViewPaymentRequests);
+            PolicyHasChild(policyMap,Policies.CanModifyProfile, Policies.CanViewProfile);
+            PolicyHasChild(policyMap,Policies.CanUseLightningNodeInStore, Policies.CanViewLightningInvoiceInStore, Policies.CanCreateLightningInvoiceInStore);
+            PolicyHasChild(policyMap,Policies.CanManageNotificationsForUser, Policies.CanViewNotificationsForUser);
+            PolicyHasChild(policyMap,Policies.CanModifyServerSettings,
                 Policies.CanUseInternalLightningNode,
                 Policies.CanManageUsers);
-            PolicyHasChild(Policies.CanUseInternalLightningNode, Policies.CanCreateLightningInvoiceInternalNode,Policies.CanViewLightningInvoiceInternalNode );
-            PolicyHasChild(Policies.CanManageCustodianAccounts, Policies.CanViewCustodianAccounts );
-            PolicyHasChild(Policies.CanModifyInvoices, Policies.CanViewInvoices, Policies.CanCreateInvoice );
-            PolicyHasChild(Policies.CanViewStoreSettings, Policies.CanViewInvoices, Policies.CanViewPaymentRequests  );
-            
+            PolicyHasChild(policyMap, Policies.CanUseInternalLightningNode, Policies.CanCreateLightningInvoiceInternalNode, Policies.CanViewLightningInvoiceInternalNode);
+            PolicyHasChild(policyMap, Policies.CanManageCustodianAccounts, Policies.CanViewCustodianAccounts);
+            PolicyHasChild(policyMap, Policies.CanModifyInvoices, Policies.CanViewInvoices, Policies.CanCreateInvoice, Policies.CanCreateLightningInvoiceInStore);
+            PolicyHasChild(policyMap, Policies.CanViewStoreSettings, Policies.CanViewInvoices, Policies.CanViewPaymentRequests);
+
+            var missingPolicies = Policies.AllPolicies.ToHashSet();
+            //recurse through the tree to see which policies are not included in the tree
+            foreach (var policy in policyMap)
+            {
+                missingPolicies.Remove(policy.Key);
+                foreach (var subPolicy in policy.Value)
+                {
+                    missingPolicies.Remove(subPolicy);
+                }
+            }
+
+            foreach (var missingPolicy in missingPolicies)
+            {
+                policyMap.Add(missingPolicy, new HashSet<string>());
+            }
+            return new ReadOnlyDictionary<string, HashSet<string>>(policyMap);
         }
 
-        private static void PolicyHasChild(string policy, params string[] subPolicies)
+        private static void PolicyHasChild(Dictionary<string, HashSet<string>>policyMap, string policy, params string[] subPolicies)
         {
-            if (PolicyMap.TryGetValue(policy, out var existingSubPolicies))
+            if (policyMap.TryGetValue(policy, out var existingSubPolicies))
             {
                 foreach (string subPolicy in subPolicies)
                 {
@@ -243,33 +296,26 @@ namespace BTCPayServer.Client
             }
             else
             {
-                PolicyMap.Add(policy,subPolicies.ToHashSet());
+                policyMap.Add(policy, subPolicies.ToHashSet());
             }
         }
-        
 
         public string Scope { get; }
         public string Policy { get; }
 
         public override string ToString()
         {
-            if (Scope != null)
-            {
-                return $"{Policy}:{Scope}";
-            }
-            return Policy;
+            return Scope != null ? $"{Policy}:{Scope}" : Policy;
         }
 
         public override bool Equals(object obj)
         {
             Permission item = obj as Permission;
-            if (item == null)
-                return false;
-            return ToString().Equals(item.ToString());
+            return item != null && ToString().Equals(item.ToString());
         }
         public static bool operator ==(Permission a, Permission b)
         {
-            if (System.Object.ReferenceEquals(a, b))
+            if (ReferenceEquals(a, b))
                 return true;
             if (((object)a == null) || ((object)b == null))
                 return false;

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.BGold.cs

@@ -16,7 +16,7 @@ namespace BTCPayServer
                 DefaultRateRules = new[]
                 {
                     "BTG_X = BTG_BTC * BTC_X",
-                    "BTG_BTC = bitfinex(BTG_BTC)",
+                    "BTG_BTC = exmo(BTG_BTC)",
                 },
                 CryptoImagePath = "imlegacy/btg.svg",
                 LightningImagePath = "imlegacy/btg-lightning.svg",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Bitcore.cs

@@ -17,7 +17,7 @@ namespace BTCPayServer
                 DefaultRateRules = new[]
                 {
                                 "BTX_X = BTX_BTC * BTC_X",
-                                "BTX_BTC = hitbtc(BTX_BTC)"
+                                "BTX_BTC = graviex(BTX_BTC)"
                 },
                 CryptoImagePath = "imlegacy/bitcore.svg",
                 LightningImagePath = "imlegacy/bitcore-lightning.svg",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Chaincoin.cs

@@ -1,32 +0,0 @@
-using NBitcoin;
-
-namespace BTCPayServer
-{
-    public partial class BTCPayNetworkProvider
-    {
-        public void InitChaincoin()
-        {
-            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("CHC");
-            Add(new BTCPayNetwork()
-            {
-                CryptoCode = nbxplorerNetwork.CryptoCode,
-                DisplayName = "Chaincoin",
-                BlockExplorerLink = NetworkType == ChainName.Mainnet
-                    ? "https://explorer.chaincoin.org/Explorer/Transaction/{0}"
-                    : "https://test.explorer.chaincoin.org/Explorer/Transaction/tx/{0}",
-                NBXplorerNetwork = nbxplorerNetwork,
-                DefaultRateRules = new[]
-                    {
-                        "CHC_X = CHC_BTC * BTC_X",
-                        "CHC_BTC = txbit(CHC_X)"
-                    },
-                CryptoImagePath = "imlegacy/chaincoin.png",
-                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                //https://github.com/satoshilabs/slips/blob/master/slip-0044.md
-                CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("711'")
-                    : new KeyPath("1'")
-            });
-        }
-    }
-}
-

BTCPayServer.Common/Altcoins/Liquid/BTCPayNetworkProvider.LiquidAssets.cs

@@ -63,6 +63,7 @@ namespace BTCPayServer
                     "LCAD_CAD = 1",
                     "LCAD_X = CAD_BTC * BTC_X",
                     "LCAD_BTC = bylls(CAD_BTC)",
+                    "CAD_BTC = LCAD_BTC"
                 },
                 AssetId = new uint256("0e99c1a6da379d1f4151fb9df90449d40d0608f6cb33a5bcbfc8c265f42bab0a"),
                 DisplayName = "Liquid CAD",

BTCPayServer.Common/Altcoins/Liquid/ElementsLikeBtcPayNetwork.cs

@@ -1,4 +1,5 @@
 #if ALTCOINS
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using BTCPayServer.Common;
@@ -34,12 +35,12 @@ namespace BTCPayServer
                     output.Value is AssetMoney assetMoney && assetMoney.AssetId == AssetId));
         }
 
-        public override PaymentUrlBuilder GenerateBIP21(string cryptoInfoAddress, Money cryptoInfoDue)
+        public override PaymentUrlBuilder GenerateBIP21(string cryptoInfoAddress, decimal? cryptoInfoDue)
         {
             //precision 0: 10 = 0.00000010
             //precision 2: 10 = 0.00001000
             //precision 8: 10 = 10
-            var money = cryptoInfoDue is null ? null : new Money(cryptoInfoDue.ToDecimal(MoneyUnit.BTC) / decimal.Parse("1".PadRight(1 + 8 - Divisibility, '0')), MoneyUnit.BTC);
+            var money = cryptoInfoDue / (decimal)Math.Pow(10, 8 - Divisibility);
             var builder = base.GenerateBIP21(cryptoInfoAddress, money);
             builder.QueryParams.Add("assetid", AssetId.ToString());
             return builder;

BTCPayServer.Common/Altcoins/Monero/RPC/JsonRpcClient.cs

@@ -45,10 +45,10 @@ namespace BTCPayServer.Services.Altcoins.Monero.RPC
             httpRequest.Headers.Authorization = new AuthenticationHeaderValue("Basic",
                 Convert.ToBase64String(Encoding.Default.GetBytes($"{_username}:{_password}")));
 
-            var rawResult = await _httpClient.SendAsync(httpRequest, cts);
-
-            var rawJson = await rawResult.Content.ReadAsStringAsync();
+            HttpResponseMessage rawResult = await _httpClient.SendAsync(httpRequest, cts);
             rawResult.EnsureSuccessStatusCode();
+            var rawJson = await rawResult.Content.ReadAsStringAsync();
+            
             JsonRpcResult<TResponse> response;
             try
             {

BTCPayServer.Common/BTCPayNetwork.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using BTCPayServer.Common;
@@ -87,13 +88,13 @@ namespace BTCPayServer
             });
         }
 
-        public virtual PaymentUrlBuilder GenerateBIP21(string cryptoInfoAddress, Money cryptoInfoDue)
+        public virtual PaymentUrlBuilder GenerateBIP21(string cryptoInfoAddress, decimal? cryptoInfoDue)
         {
             var builder = new PaymentUrlBuilder(this.NBitcoinNetwork.UriScheme);
             builder.Host = cryptoInfoAddress;
-            if (cryptoInfoDue != null && cryptoInfoDue != Money.Zero)
+            if (cryptoInfoDue is not null && cryptoInfoDue.Value != 0.0m)
             {
-                builder.QueryParams.Add("amount", cryptoInfoDue.ToString(false, true));
+                builder.QueryParams.Add("amount", cryptoInfoDue.Value.ToString(CultureInfo.InvariantCulture));
             }
             return builder;
         }

BTCPayServer.Common/BTCPayNetworkProvider.cs

@@ -56,7 +56,6 @@ namespace BTCPayServer
             InitViacoin();
             InitMonero();
             InitZcash();
-            InitChaincoin();
             // InitArgoneum();//their rate source is down 9/15/20.
             // InitMonetaryUnit(); Not supported from Bittrex from 11/23/2022, dead shitcoin
 

BTCPayServer.Common/BTCPayServer.Common.csproj

@@ -4,7 +4,7 @@
 
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="NBXplorer.Client" Version="4.2.3" />
+    <PackageReference Include="NBXplorer.Client" Version="4.2.5" />
     <PackageReference Include="NicolasDorier.StandardConfiguration" Version="2.0.1" />
   </ItemGroup>
   <ItemGroup Condition="'$(Altcoins)' != 'true'">

BTCPayServer.Data/ApplicationDbContext.cs

@@ -64,6 +64,7 @@ namespace BTCPayServer.Data
         public DbSet<U2FDevice> U2FDevices { get; set; }
         public DbSet<Fido2Credential> Fido2Credentials { get; set; }
         public DbSet<UserStore> UserStore { get; set; }
+        public DbSet<StoreRole> StoreRoles { get; set; }
         [Obsolete]
         public DbSet<WalletData> Wallets { get; set; }
         public DbSet<WalletObjectData> WalletObjects { get; set; }
@@ -124,14 +125,15 @@ namespace BTCPayServer.Data
 #pragma warning disable CS0612 // Type or member is obsolete
             WalletTransactionData.OnModelCreating(builder);
 #pragma warning restore CS0612 // Type or member is obsolete
-			WebhookDeliveryData.OnModelCreating(builder, Database);
-			LightningAddressData.OnModelCreating(builder, Database);
-			PayoutProcessorData.OnModelCreating(builder, Database);
-			WebhookData.OnModelCreating(builder, Database);
-			FormData.OnModelCreating(builder, Database);
+            WebhookDeliveryData.OnModelCreating(builder, Database);
+            LightningAddressData.OnModelCreating(builder, Database);
+            PayoutProcessorData.OnModelCreating(builder, Database);
+            WebhookData.OnModelCreating(builder, Database);
+            FormData.OnModelCreating(builder, Database);
+            StoreRole.OnModelCreating(builder, Database);
 
 
-			if (Database.IsSqlite() && !_designTime)
+            if (Database.IsSqlite() && !_designTime)
             {
                 // SQLite does not have proper support for DateTimeOffset via Entity Framework Core, see the limitations
                 // here: https://docs.microsoft.com/en-us/ef/core/providers/sqlite/limitations#query-limitations

BTCPayServer.Data/ApplicationDbContextFactory.cs

@@ -1,3 +1,6 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
 using BTCPayServer.Abstractions.Contracts;
 using BTCPayServer.Abstractions.Models;
 using Microsoft.EntityFrameworkCore;

BTCPayServer.Data/Data/FormData.cs

@@ -13,14 +13,14 @@ public class FormData
     public StoreData Store { get; set; }
     public string Config { get; set; }
     public bool Public { get; set; }
-    
+
     internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
     {
         builder.Entity<FormData>()
             .HasOne(o => o.Store)
             .WithMany(o => o.Forms).OnDelete(DeleteBehavior.Cascade);
         builder.Entity<FormData>().HasIndex(o => o.StoreId);
-        
+
         if (databaseFacade.IsNpgsql())
         {
             builder.Entity<FormData>()

BTCPayServer.Data/Data/LightingAddressData.cs

@@ -1,6 +1,9 @@
 using System;
+using System.Collections.Generic;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Data;
 
@@ -38,4 +41,9 @@ public class LightningAddressDataBlob
     public string CurrencyCode { get; set; }
     public decimal? Min { get; set; }
     public decimal? Max { get; set; }
+
+    public JObject InvoiceMetadata { get; set; }
+    
+    [JsonExtensionData] public Dictionary<string, JToken> AdditionalData { get; set; }
+    
 }

BTCPayServer.Data/Data/NotificationData.cs

@@ -24,8 +24,8 @@ namespace BTCPayServer.Data
         public string Blob2 { get; set; }
 
 
-		internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
-		{
+        internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
+        {
             builder.Entity<NotificationData>()
                 .HasOne(o => o.ApplicationUser)
                 .WithMany(n => n.Notifications)

BTCPayServer.Data/Data/PayoutProcessorData.cs

@@ -8,6 +8,7 @@ namespace BTCPayServer.Data;
 public class AutomatedPayoutBlob
 {
     public TimeSpan Interval { get; set; } = TimeSpan.FromHours(1);
+    public bool ProcessNewPayoutsInstantly { get; set; }
 }
 public class PayoutProcessorData : IHasBlobUntyped
 {

BTCPayServer.Data/Data/StoreData.cs

@@ -1,12 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel.DataAnnotations.Schema;
 using System.Text;
 using BTCPayServer.Client.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using PayoutProcessorData = BTCPayServer.Data.PayoutProcessorData;
 
 namespace BTCPayServer.Data
 {
@@ -36,8 +34,6 @@ namespace BTCPayServer.Data
 
         public byte[] StoreCertificate { get; set; }
 
-        [NotMapped] public string Role { get; set; }
-
         public string StoreBlob { get; set; }
 
         [Obsolete("Use GetDefaultPaymentId instead")]
@@ -51,6 +47,7 @@ namespace BTCPayServer.Data
         public IEnumerable<CustodianAccountData> CustodianAccounts { get; set; }
         public IEnumerable<StoreSettingData> Settings { get; set; }
         public IEnumerable<FormData> Forms { get; set; }
+        public IEnumerable<StoreRole> StoreRoles { get; set; }
 
         internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
         {

BTCPayServer.Data/Data/StoreRole.cs

@@ -0,0 +1,50 @@
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Data;
+
+public class StoreRole
+{
+    public string Id { get; set; }
+    public string StoreDataId { get; set; }
+    public string Role { get; set; }
+    public List<string> Permissions { get; set; }
+    public List<UserStore> Users { get; set; }
+    public StoreData StoreData { get; set; }
+
+    internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
+    {
+        builder.Entity<StoreRole>(entity =>
+        {
+            entity.HasOne(e => e.StoreData)
+                .WithMany(s => s.StoreRoles)
+                .HasForeignKey(e => e.StoreDataId)
+                .OnDelete(DeleteBehavior.Cascade)
+                .IsRequired(false);
+            
+            entity.HasIndex(entity => new {entity.StoreDataId, entity.Role}).IsUnique();
+        });
+        
+        
+        
+        if (!databaseFacade.IsNpgsql())
+        {
+            builder.Entity<StoreRole>()
+                .Property(o => o.Permissions)
+                .HasConversion(
+                    v => JsonConvert.SerializeObject(v),
+                    v => JsonConvert.DeserializeObject<List<string>>(v)?? new List<string>(),
+                    new ValueComparer<List<string>>(
+                        (c1, c2) =>  c1 ==c2 || c1 != null && c2 != null && c1.SequenceEqual(c2),
+                        c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
+                        c => c.ToList()));
+        }
+    }
+}

BTCPayServer.Data/Data/UserStore.cs

@@ -1,3 +1,4 @@
+using System.ComponentModel.DataAnnotations.Schema;
 using Microsoft.EntityFrameworkCore;
 
 namespace BTCPayServer.Data
@@ -9,7 +10,10 @@ namespace BTCPayServer.Data
 
         public string StoreDataId { get; set; }
         public StoreData StoreData { get; set; }
-        public string Role { get; set; }
+        [Column("Role")]
+        public string StoreRoleId { get; set; }
+        public StoreRole StoreRole { get; set; }
+        
 
 
         internal static void OnModelCreating(ModelBuilder builder)
@@ -32,6 +36,10 @@ namespace BTCPayServer.Data
                 .HasOne(pt => pt.StoreData)
                 .WithMany(t => t.UserStores)
                 .HasForeignKey(pt => pt.StoreDataId);
+
+            builder.Entity<UserStore>().HasOne(e => e.StoreRole)
+                .WithMany(role => role.Users)
+                .HasForeignKey(e => e.StoreRoleId);
         }
     }
 }

BTCPayServer.Data/Data/WebhookDeliveryData.cs

@@ -5,7 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
 
 namespace BTCPayServer.Data
 {
-    public class WebhookDeliveryData : IHasBlobUntyped
+    public class WebhookDeliveryData
     {
         [Key]
         [MaxLength(25)]
@@ -17,10 +17,8 @@ namespace BTCPayServer.Data
 
         [Required]
         public DateTimeOffset Timestamp { get; set; }
-        [Obsolete("Use Blob2 instead")]
-        public byte[] Blob { get; set; }
-        public string Blob2 { get; set; }
-
+        public string Blob { get; set; }
+        public bool Pruned { get; set; }
 
         internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
         {
@@ -28,11 +26,11 @@ namespace BTCPayServer.Data
                 .HasOne(o => o.Webhook)
                 .WithMany(a => a.Deliveries).OnDelete(DeleteBehavior.Cascade);
             builder.Entity<WebhookDeliveryData>().HasIndex(o => o.WebhookId);
-
+            builder.Entity<WebhookDeliveryData>().HasIndex(o => o.Timestamp);
             if (databaseFacade.IsNpgsql())
             {
                 builder.Entity<WebhookDeliveryData>()
-                    .Property(o => o.Blob2)
+                    .Property(o => o.Blob)
                     .HasColumnType("JSONB");
             }
         }

BTCPayServer.Data/Migrations/20230125085242_AddForms.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using BTCPayServer.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;

BTCPayServer.Data/Migrations/20230315062447_fixmaxlength.cs

@@ -0,0 +1,31 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20230315062447_fixmaxlength")]
+    public partial class fixmaxlength : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            if (migrationBuilder.IsNpgsql())
+            {
+                migrationBuilder.Sql("ALTER TABLE \"InvoiceSearches\" ALTER COLUMN \"Value\" TYPE TEXT USING \"Value\"::TEXT;");
+                migrationBuilder.Sql("ALTER TABLE \"Invoices\"  ALTER COLUMN \"OrderId\" TYPE TEXT USING \"OrderId\"::TEXT;");
+            }
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            // Not supported
+        }
+    }
+}

BTCPayServer.Data/Migrations/20230504125505_StoreRoles.cs

@@ -0,0 +1,106 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using NBitcoin;
+using Newtonsoft.Json;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20230504125505_StoreRoles")]
+    public partial class StoreRoles : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            var permissionsType = migrationBuilder.IsNpgsql() ? "TEXT[]" : "TEXT";
+            migrationBuilder.CreateTable(
+                name: "StoreRoles",
+                columns: table => new
+                {
+                    Id = table.Column<string>(type: "TEXT", nullable: false),
+                    StoreDataId = table.Column<string>(type: "TEXT", nullable: true),
+                    Role = table.Column<string>(type: "TEXT", nullable: false),
+                    Permissions = table.Column<string>(type: permissionsType, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_StoreRoles", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_StoreRoles_Stores_StoreDataId",
+                        column: x => x.StoreDataId,
+                        principalTable: "Stores",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_StoreRoles_StoreDataId_Role",
+                table: "StoreRoles",
+                columns: new[] { "StoreDataId", "Role" },
+                unique: true);
+
+            object GetPermissionsData(string[] permissions)
+            {
+                if (migrationBuilder.IsNpgsql())
+                    return permissions;
+                return JsonConvert.SerializeObject(permissions);
+            }
+
+            migrationBuilder.InsertData(
+                "StoreRoles",
+                columns: new[] { "Id", "Role", "Permissions" },
+                columnTypes: new[] { "TEXT", "TEXT", permissionsType },
+                values: new object[,]
+                {
+                    {
+                        "Owner", "Owner", GetPermissionsData(new[]
+                        {
+                            "btcpay.store.canmodifystoresettings",
+                            "btcpay.store.cantradecustodianaccount",
+                            "btcpay.store.canwithdrawfromcustodianaccount",
+                            "btcpay.store.candeposittocustodianaccount"
+                        })
+                    },
+                    {
+                        "Guest", "Guest", GetPermissionsData(new[]
+                        {
+                            "btcpay.store.canviewstoresettings",
+                            "btcpay.store.canmodifyinvoices",
+                            "btcpay.store.canviewcustodianaccounts",
+                            "btcpay.store.candeposittocustodianaccount"
+                        })
+                }
+                });
+
+            if (this.SupportAddForeignKey(migrationBuilder.ActiveProvider))
+            {
+                
+                migrationBuilder.AddForeignKey(
+                    name: "FK_UserStore_StoreRoles_Role",
+                    table: "UserStore",
+                    column: "Role",
+                    principalTable: "StoreRoles",
+                    principalColumn: "Id");
+            }
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+            if (this.SupportDropForeignKey(migrationBuilder.ActiveProvider))
+            {
+                migrationBuilder.DropForeignKey(
+                    name: "FK_UserStore_StoreRoles_Role",
+                    table: "UserStore");
+            }
+
+            migrationBuilder.DropTable(
+                name: "StoreRoles");
+        }
+    }
+}

BTCPayServer.Data/Migrations/20230529135505_WebhookDeliveriesCleanup.cs

@@ -0,0 +1,83 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using NBitcoin;
+using Newtonsoft.Json;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20230529135505_WebhookDeliveriesCleanup")]
+    public partial class WebhookDeliveriesCleanup : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            if (migrationBuilder.IsNpgsql())
+            {
+                migrationBuilder.Sql("DROP TABLE IF EXISTS \"InvoiceWebhookDeliveries\", \"WebhookDeliveries\";");
+
+                migrationBuilder.CreateTable(
+                name: "WebhookDeliveries",
+                columns: table => new
+                {
+                    Id = table.Column<string>(type: "TEXT", nullable: false),
+                    WebhookId = table.Column<string>(type: "TEXT", nullable: false),
+                    Timestamp = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    Pruned = table.Column<bool>(type: "BOOLEAN", nullable: false),
+                    Blob = table.Column<string>(type: "JSONB", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WebhookDeliveries", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_WebhookDeliveries_Webhooks_WebhookId",
+                        column: x => x.WebhookId,
+                        principalTable: "Webhooks",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+
+                migrationBuilder.CreateIndex(
+                    name: "IX_WebhookDeliveries_WebhookId",
+                    table: "WebhookDeliveries",
+                    column: "WebhookId");
+                migrationBuilder.Sql("CREATE INDEX \"IX_WebhookDeliveries_Timestamp\" ON \"WebhookDeliveries\"(\"Timestamp\") WHERE \"Pruned\" IS FALSE");
+
+                migrationBuilder.CreateTable(
+                name: "InvoiceWebhookDeliveries",
+                columns: table => new
+                {
+                    InvoiceId = table.Column<string>(type: "TEXT", nullable: false),
+                    DeliveryId = table.Column<string>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_InvoiceWebhookDeliveries", x => new { x.InvoiceId, x.DeliveryId });
+                    table.ForeignKey(
+                        name: "FK_InvoiceWebhookDeliveries_WebhookDeliveries_DeliveryId",
+                        column: x => x.DeliveryId,
+                        principalTable: "WebhookDeliveries",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_InvoiceWebhookDeliveries_Invoices_InvoiceId",
+                        column: x => x.InvoiceId,
+                        principalTable: "Invoices",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+            }
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

BTCPayServer.Data/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -214,56 +214,6 @@ namespace BTCPayServer.Migrations
                     b.ToTable("CustodianAccount");
                 });
 
-            modelBuilder.Entity("BTCPayServer.Data.FormData", b =>
-                {
-                    b.Property<string>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Config")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("Public")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("StoreId")
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StoreId");
-
-                    b.ToTable("Forms");
-                });
-
-            modelBuilder.Entity("BTCPayServer.Data.PayoutProcessorData", b =>
-                {
-                    b.Property<string>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT");
-
-                    b.Property<byte[]>("Blob")
-                        .HasColumnType("BLOB");
-
-                    b.Property<string>("PaymentMethod")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Processor")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("StoreId")
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StoreId");
-
-                    b.ToTable("PayoutProcessors");
-                });
-
             modelBuilder.Entity("BTCPayServer.Data.Fido2Credential", b =>
                 {
                     b.Property<string>("Id")
@@ -292,6 +242,31 @@ namespace BTCPayServer.Migrations
                     b.ToTable("Fido2Credentials");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.FormData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Config")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Public")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("StoreId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreId");
+
+                    b.ToTable("Forms");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
                 {
                     b.Property<string>("Id")
@@ -655,6 +630,34 @@ namespace BTCPayServer.Migrations
                     b.ToTable("Payouts");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.PayoutProcessorData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Blob")
+                        .HasColumnType("BLOB");
+
+                    b.Property<string>("Blob2")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PaymentMethod")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Processor")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StoreId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreId");
+
+                    b.ToTable("PayoutProcessors");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
                 {
                     b.Property<string>("Id")
@@ -802,6 +805,28 @@ namespace BTCPayServer.Migrations
                     b.ToTable("Files");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.StoreRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Permissions")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StoreDataId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId", "Role")
+                        .IsUnique();
+
+                    b.ToTable("StoreRoles");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.StoreSettingData", b =>
                 {
                     b.Property<string>("StoreId")
@@ -878,13 +903,16 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("StoreDataId")
                         .HasColumnType("TEXT");
 
-                    b.Property<string>("Role")
-                        .HasColumnType("TEXT");
+                    b.Property<string>("StoreRoleId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("Role");
 
                     b.HasKey("ApplicationUserId", "StoreDataId");
 
                     b.HasIndex("StoreDataId");
 
+                    b.HasIndex("StoreRoleId");
+
                     b.ToTable("UserStore");
                 });
 
@@ -991,12 +1019,12 @@ namespace BTCPayServer.Migrations
                         .HasMaxLength(25)
                         .HasColumnType("TEXT");
 
-                    b.Property<byte[]>("Blob")
-                        .HasColumnType("BLOB");
-
-                    b.Property<string>("Blob2")
+                    b.Property<string>("Blob")
                         .HasColumnType("TEXT");
 
+                    b.Property<bool>("Pruned")
+                        .HasColumnType("INTEGER");
+
                     b.Property<DateTimeOffset>("Timestamp")
                         .HasColumnType("TEXT");
 
@@ -1007,6 +1035,8 @@ namespace BTCPayServer.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("Timestamp");
+
                     b.HasIndex("WebhookId");
 
                     b.ToTable("WebhookDeliveries");
@@ -1188,26 +1218,6 @@ namespace BTCPayServer.Migrations
                     b.Navigation("StoreData");
                 });
 
-            modelBuilder.Entity("BTCPayServer.Data.FormData", b =>
-                {
-                    b.HasOne("BTCPayServer.Data.StoreData", "Store")
-                        .WithMany("Forms")
-                        .HasForeignKey("StoreId")
-                        .OnDelete(DeleteBehavior.Cascade);
-
-                    b.Navigation("Store");
-                });
-
-            modelBuilder.Entity("BTCPayServer.Data.PayoutProcessorData", b =>
-                {
-                    b.HasOne("BTCPayServer.Data.StoreData", "Store")
-                        .WithMany("PayoutProcessors")
-                        .HasForeignKey("StoreId")
-                        .OnDelete(DeleteBehavior.Cascade);
-
-                    b.Navigation("Store");
-                });
-
             modelBuilder.Entity("BTCPayServer.Data.Fido2Credential", b =>
                 {
                     b.HasOne("BTCPayServer.Data.ApplicationUser", "ApplicationUser")
@@ -1218,6 +1228,16 @@ namespace BTCPayServer.Migrations
                     b.Navigation("ApplicationUser");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.FormData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "Store")
+                        .WithMany("Forms")
+                        .HasForeignKey("StoreId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Store");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
                 {
                     b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
@@ -1343,6 +1363,16 @@ namespace BTCPayServer.Migrations
                     b.Navigation("StoreData");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.PayoutProcessorData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "Store")
+                        .WithMany("PayoutProcessors")
+                        .HasForeignKey("StoreId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Store");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
                 {
                     b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
@@ -1392,6 +1422,16 @@ namespace BTCPayServer.Migrations
                     b.Navigation("ApplicationUser");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.StoreRole", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("StoreRoles")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("StoreData");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.StoreSettingData", b =>
                 {
                     b.HasOne("BTCPayServer.Data.StoreData", "Store")
@@ -1446,9 +1486,15 @@ namespace BTCPayServer.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.HasOne("BTCPayServer.Data.StoreRole", "StoreRole")
+                        .WithMany("Users")
+                        .HasForeignKey("StoreRoleId");
+
                     b.Navigation("ApplicationUser");
 
                     b.Navigation("StoreData");
+
+                    b.Navigation("StoreRole");
                 });
 
             modelBuilder.Entity("BTCPayServer.Data.WalletObjectLinkData", b =>
@@ -1606,9 +1652,16 @@ namespace BTCPayServer.Migrations
 
                     b.Navigation("Settings");
 
+                    b.Navigation("StoreRoles");
+
                     b.Navigation("UserStores");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.StoreRole", b =>
+                {
+                    b.Navigation("Users");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.WalletData", b =>
                 {
                     b.Navigation("WalletTransactions");

BTCPayServer.Rating/Currencies.json

@@ -1305,7 +1305,7 @@
       "name":"Satoshis",
       "code":"SATS",
       "divisibility":0,
-      "symbol":"Sats",
+      "symbol":"sats",
       "crypto":true
    },
    {

BTCPayServer.Rating/CurrencyNameTable.cs

@@ -5,7 +5,6 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Text;
-using BTCPayServer.Rating;
 using NBitcoin;
 using Newtonsoft.Json;
 
@@ -28,14 +27,6 @@ namespace BTCPayServer.Services.Rates
         }
 
         static readonly Dictionary<string, IFormatProvider> _CurrencyProviders = new Dictionary<string, IFormatProvider>();
-        public string FormatCurrency(string price, string currency)
-        {
-            return FormatCurrency(decimal.Parse(price, CultureInfo.InvariantCulture), currency);
-        }
-        public string FormatCurrency(decimal price, string currency)
-        {
-            return price.ToString("C", GetCurrencyProvider(currency));
-        }
 
         public NumberFormatInfo GetNumberFormatInfo(string currency, bool useFallback)
         {
@@ -56,6 +47,7 @@ namespace BTCPayServer.Services.Rates
             currencyInfo.CurrencySymbol = currency;
             return currencyInfo;
         }
+
         public NumberFormatInfo GetNumberFormatInfo(string currency)
         {
             var curr = GetCurrencyProvider(currency);
@@ -65,6 +57,7 @@ namespace BTCPayServer.Services.Rates
                 return ni;
             return null;
         }
+
         public IFormatProvider GetCurrencyProvider(string currency)
         {
             lock (_CurrencyProviders)
@@ -104,30 +97,6 @@ namespace BTCPayServer.Services.Rates
             currencyProviders.TryAdd(code, number);
         }
 
-        /// <summary>
-        /// Format a currency like "0.004 $ (USD)", round to significant divisibility
-        /// </summary>
-        /// <param name="value">The value</param>
-        /// <param name="currency">Currency code</param>
-        /// <returns></returns>
-        public string DisplayFormatCurrency(decimal value, string currency)
-        {
-            var provider = GetNumberFormatInfo(currency, true);
-            var currencyData = GetCurrencyData(currency, true);
-            var divisibility = currencyData.Divisibility;
-            value = value.RoundToSignificant(ref divisibility);
-            if (divisibility != provider.CurrencyDecimalDigits)
-            {
-                provider = (NumberFormatInfo)provider.Clone();
-                provider.CurrencyDecimalDigits = divisibility;
-            }
-
-            if (currencyData.Crypto)
-                return value.ToString("C", provider);
-            else
-                return value.ToString("C", provider) + $" ({currency})";
-        }
-
         readonly Dictionary<string, CurrencyData> _Currencies;
 
         static CurrencyData[] LoadCurrency()

BTCPayServer.Rating/Extensions.cs

@@ -15,7 +15,7 @@ namespace BTCPayServer.Rating
                 while (true)
                 {
                     var rounded = decimal.Round(value, divisibility, MidpointRounding.AwayFromZero);
-                    if ((Math.Abs(rounded - value) / value) < 0.001m)
+                    if ((Math.Abs(rounded - value) / value) < 0.01m)
                     {
                         value = rounded;
                         break;

BTCPayServer.Rating/Providers/ExchangeRateHostRateProvider.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Services.Rates;
+
+
+public class ExchangeRateHostRateProvider : IRateProvider
+{
+    public RateSourceInfo RateSourceInfo => new("exchangeratehost", "Yadio", "https://api.exchangerate.host/latest?base=BTC");
+    private readonly HttpClient _httpClient;
+    public ExchangeRateHostRateProvider(HttpClient httpClient)
+    {
+        _httpClient = httpClient ?? new HttpClient();
+    }
+
+    public async Task<PairRate[]> GetRatesAsync(CancellationToken cancellationToken)
+    {
+        var response = await _httpClient.GetAsync(RateSourceInfo.Url, cancellationToken);
+        response.EnsureSuccessStatusCode();
+        var jobj = await response.Content.ReadAsAsync<JObject>(cancellationToken);
+        if(jobj["success"].Value<bool>() is not true || !jobj["base"].Value<string>().Equals("BTC", StringComparison.InvariantCulture))
+            throw new Exception("exchangerate.host returned a non success response or the base currency was not the requested one (BTC)");
+        var results = (JObject) jobj["rates"] ;
+        //key value is currency code to rate value
+        var list = new List<PairRate>();
+        foreach (var item in results)
+        {
+            string name = item.Key;
+            var value = item.Value.Value<decimal>();
+            list.Add(new PairRate(new CurrencyPair("BTC", name), new BidAsk(value)));
+        }
+
+        return list.ToArray();
+    }
+}

BTCPayServer.Rating/Providers/FreeCurrencyRatesRateProvider.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Services.Rates;
+
+public class FreeCurrencyRatesRateProvider : IRateProvider
+{
+    public RateSourceInfo RateSourceInfo => new("free-currency-rates", "Free Currency Rates", "https://cdn.jsdelivr.net/gh/fawazahmed0/currency-api@1/latest/currencies/btc.min.json");
+    private readonly HttpClient _httpClient;
+    public FreeCurrencyRatesRateProvider(HttpClient httpClient)
+    {
+        _httpClient = httpClient ?? new HttpClient();
+    }
+
+    public async Task<PairRate[]> GetRatesAsync(CancellationToken cancellationToken)
+    {
+        var response = await _httpClient.GetAsync(RateSourceInfo.Url, cancellationToken);
+        response.EnsureSuccessStatusCode();
+        var jobj = await response.Content.ReadAsAsync<JObject>(cancellationToken);
+        var results = (JObject) jobj["btc"] ;
+        //key value is currency code to rate value
+        var list = new List<PairRate>();
+        foreach (var item in results)
+        {
+            string name = item.Key;
+            var value = item.Value.Value<decimal>();
+            list.Add(new PairRate(new CurrencyPair("BTC", name), new BidAsk(value)));
+        }
+
+        return list.ToArray();
+    }
+}

BTCPayServer.Rating/Providers/NullRateProvider.cs

@@ -20,7 +20,7 @@ namespace BTCPayServer.Services.Rates
             }
         }
 
-        public RateSourceInfo RateSourceInfo => new RateSourceInfo("NULL","NULL", "https://NULL.NULL");
+        public RateSourceInfo RateSourceInfo => new RateSourceInfo("NULL", "NULL", "https://NULL.NULL");
 
         public Task<PairRate[]> GetRatesAsync(CancellationToken cancellationToken)
         {

BTCPayServer.Rating/Services/RateProviderFactory.cs

@@ -89,7 +89,7 @@ namespace BTCPayServer.Services.Rates
                     AvailableRateProviders.Add(new(rsi.Id, rsi.DisplayName, rsi.Url, RateSource.Coingecko));
                 }
             }
-            AvailableRateProviders.Sort((a,b) => StringComparer.Ordinal.Compare(a.DisplayName, b.DisplayName));
+            AvailableRateProviders.Sort((a, b) => StringComparer.Ordinal.Compare(a.DisplayName, b.DisplayName));
         }
 
         public List<AvailableRateProvider> AvailableRateProviders { get; } = new List<AvailableRateProvider>();

BTCPayServer.Tests/AltcoinTests/AltcoinTests.cs

@@ -6,11 +6,13 @@ using System.Threading.Tasks;
 using BTCPayServer.Controllers;
 using BTCPayServer.Data;
 using BTCPayServer.HostedServices;
+using BTCPayServer.Hosting;
 using BTCPayServer.Lightning;
 using BTCPayServer.Models.AppViewModels;
 using BTCPayServer.Models.StoreViewModels;
 using BTCPayServer.Models.WalletViewModels;
 using BTCPayServer.Payments;
+using BTCPayServer.Plugins.PointOfSale;
 using BTCPayServer.Plugins.PointOfSale.Controllers;
 using BTCPayServer.Plugins.PointOfSale.Models;
 using BTCPayServer.Services.Apps;
@@ -50,6 +52,7 @@ namespace BTCPayServer.Tests
                 user.RegisterDerivationScheme(cryptoCode);
                 user.RegisterDerivationScheme("LTC");
                 user.RegisterLightningNode(cryptoCode, LightningConnectionType.CLightning);
+                user.SetLNUrl("BTC", false);
                 var btcNetwork = tester.PayTester.Networks.GetNetwork<BTCPayNetwork>(cryptoCode);
                 var invoice = await user.BitPay.CreateInvoiceAsync(
                     new Invoice
@@ -243,7 +246,7 @@ namespace BTCPayServer.Tests
                 await tester.EnsureChannelsSetup();
                 var user = tester.NewAccount();
                 user.GrantAccess(true);
-                user.RegisterLightningNode("BTC", LightningConnectionType.Charge);
+                user.RegisterLightningNode("BTC");
                 user.RegisterDerivationScheme("BTC");
                 user.RegisterDerivationScheme("LTC");
 
@@ -386,7 +389,7 @@ namespace BTCPayServer.Tests
             s.Driver.FindElement(By.Id("BOLT11Expiration")).SendKeys("5" + Keys.Enter);
             s.GoToInvoice(invoice.Id);
             s.Driver.FindElement(By.Id("IssueRefund")).Click();
-            
+
             if (multiCurrency)
             {
                 s.Driver.WaitUntilAvailable(By.Id("RefundForm"), TimeSpan.FromSeconds(1));
@@ -396,21 +399,21 @@ namespace BTCPayServer.Tests
             }
 
             s.Driver.WaitUntilAvailable(By.Id("RefundForm"), TimeSpan.FromSeconds(1));
-            Assert.Contains("$5,500.00", s.Driver.PageSource); // Should propose reimburse in fiat
-            Assert.Contains("1.10000000 ₿", s.Driver.PageSource); // Should propose reimburse in BTC at the rate of before
-            Assert.Contains("2.20000000 ₿", s.Driver.PageSource); // Should propose reimburse in BTC at the current rate
+            Assert.Contains("5,500.00 USD", s.Driver.PageSource); // Should propose reimburse in fiat
+            Assert.Contains("1.10000000 BTC", s.Driver.PageSource); // Should propose reimburse in BTC at the rate of before
+            Assert.Contains("2.20000000 BTC", s.Driver.PageSource); // Should propose reimburse in BTC at the current rate
             s.Driver.WaitForAndClick(By.Id(rateSelection));
             s.Driver.FindElement(By.Id("ok")).Click();
-            
+
             s.Driver.WaitUntilAvailable(By.Id("Destination"), TimeSpan.FromSeconds(1));
             Assert.Contains("pull-payments", s.Driver.Url);
             if (rateSelection == "FiatOption")
-                Assert.Contains("$5,500.00", s.Driver.PageSource);
+                Assert.Contains("5,500.00 USD", s.Driver.PageSource);
             if (rateSelection == "CurrentOption")
-                Assert.Contains("2.20000000 ₿", s.Driver.PageSource);
+                Assert.Contains("2.20000000 BTC", s.Driver.PageSource);
             if (rateSelection == "RateThenOption")
-                Assert.Contains("1.10000000 ₿", s.Driver.PageSource);
-            
+                Assert.Contains("1.10000000 BTC", s.Driver.PageSource);
+
             s.GoToInvoice(invoice.Id);
             s.Driver.FindElement(By.Id("IssueRefund")).Click();
             s.Driver.WaitUntilAvailable(By.Id("Destination"), TimeSpan.FromSeconds(1));
@@ -584,7 +587,7 @@ namespace BTCPayServer.Tests
                 Assert.True(invoice.SupportedTransactionCurrencies["LTC"].Enabled);
                 Assert.True(invoice.PaymentSubtotals.ContainsKey("LTC"));
                 Assert.True(invoice.PaymentTotals.ContainsKey("LTC"));
-                
+
                 // Check if we can disable LTC
                 invoice = await user.BitPay.CreateInvoiceAsync(
                     new Invoice
@@ -622,10 +625,11 @@ namespace BTCPayServer.Tests
                 var apps = user.GetController<UIAppsController>();
                 var pos = user.GetController<UIPointOfSaleController>();
                 var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp(user.StoreId)).Model);
-                var appType = AppType.PointOfSale.ToString();
+                var appType = PointOfSaleAppType.AppType;
                 vm.AppName = "test";
                 vm.SelectedAppType = appType;
-                Assert.IsType<RedirectToActionResult>(apps.CreateApp(user.StoreId, vm).Result);
+                var redirect = Assert.IsType<RedirectResult>(apps.CreateApp(user.StoreId, vm).Result);
+                Assert.EndsWith("/settings/pos", redirect.Url);
                 var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps(user.StoreId).Result).Model);
                 var app = appList.Apps[0];
                 var appData = new AppData { Id = app.Id, StoreDataId = app.StoreId, Name = app.AppName, AppType = appType };
@@ -648,6 +652,7 @@ donation:
   price: 1.02
   custom: true
 ";
+                vmpos.Template = AppService.SerializeTemplate(MigrationStartupTask.ParsePOSYML(vmpos.Template));
                 Assert.IsType<RedirectToActionResult>(pos.UpdatePointOfSale(app.Id, vmpos).Result);
                 vmpos = await pos.UpdatePointOfSale(app.Id).AssertViewModelAsync<UpdatePointOfSaleViewModel>();
                 Assert.Equal("hello", vmpos.Title);
@@ -659,13 +664,12 @@ donation:
                 Assert.Equal("good apple", vmview.Items[0].Title);
                 Assert.Equal("orange", vmview.Items[1].Title);
                 Assert.Equal(10.0m, vmview.Items[1].Price.Value);
-                Assert.Equal("$5.00", vmview.Items[0].Price.Formatted);
                 Assert.Equal("{0} Purchase", vmview.ButtonText);
                 Assert.Equal("Nicolas Sexy Hair", vmview.CustomButtonText);
                 Assert.Equal("Wanna tip?", vmview.CustomTipText);
                 Assert.Equal("15,18,20", string.Join(',', vmview.CustomTipPercentages));
                 Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 0, null, null, null, null, "orange").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Cart, 0, choiceKey: "orange").Result);
 
                 //
                 var invoices = await user.BitPay.GetInvoicesAsync();
@@ -674,16 +678,16 @@ donation:
                 Assert.Equal("CAD", orangeInvoice.Currency);
                 Assert.Equal("orange", orangeInvoice.ItemDesc);
                 Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 0, null, null, null, null, "apple").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Cart, 0, choiceKey: "apple").Result);
 
                 invoices = user.BitPay.GetInvoices();
                 var appleInvoice = invoices.SingleOrDefault(invoice => invoice.ItemCode.Equals("apple"));
                 Assert.NotNull(appleInvoice);
                 Assert.Equal("good apple", appleInvoice.ItemDesc);
-                
+
                 // testing custom amount
                 var action = Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 6.6m, null, null, null, null, "donation").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Cart, 6.6m, choiceKey: "donation").Result);
                 Assert.Equal(nameof(UIInvoiceController.Checkout), action.ActionName);
                 invoices = user.BitPay.GetInvoices();
                 var donationInvoice = invoices.Single(i => i.Price == 6.6m);
@@ -720,6 +724,7 @@ donation:
   price: 1.02
   custom: true
 ";
+                    vmpos.Template = AppService.SerializeTemplate(MigrationStartupTask.ParsePOSYML(vmpos.Template));
                     Assert.IsType<RedirectToActionResult>(pos.UpdatePointOfSale(app.Id, vmpos).Result);
                     publicApps = user.GetController<UIPointOfSaleController>();
                     vmview = await publicApps.ViewPointOfSale(app.Id, PosViewType.Cart).AssertViewModelAsync<ViewPointOfSaleViewModel>();
@@ -735,7 +740,7 @@ donation:
                     Assert.Equal(test.ExpectedDivisibility, vmview.CurrencyInfo.Divisibility);
                     Assert.Equal(test.ExpectedSymbolSpace, vmview.CurrencyInfo.SymbolSpace);
                 }
-                
+
                 //test inventory related features
                 vmpos = await pos.UpdatePointOfSale(app.Id).AssertViewModelAsync<UpdatePointOfSaleViewModel>();
                 vmpos.Title = "hello";
@@ -747,26 +752,28 @@ inventoryitem:
   inventory: 1
 noninventoryitem:
   price: 10.0";
+                
+                vmpos.Template = AppService.SerializeTemplate(MigrationStartupTask.ParsePOSYML(vmpos.Template));
                 Assert.IsType<RedirectToActionResult>(pos.UpdatePointOfSale(app.Id, vmpos).Result);
 
                 //inventoryitem has 1 item available
                 await tester.WaitForEvent<AppInventoryUpdaterHostedService.UpdateAppInventory>(() =>
                 {
                     Assert.IsType<RedirectToActionResult>(publicApps
-                        .ViewPointOfSale(app.Id, PosViewType.Cart, 1, null, null, null, null, "inventoryitem").Result);
+                        .ViewPointOfSale(app.Id, PosViewType.Cart, 1, choiceKey: "inventoryitem").Result);
                     return Task.CompletedTask;
                 });
-                
+
                 //we already bought all available stock so this should fail
                 await Task.Delay(100);
                 Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, null, null, null, null, "inventoryitem").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, choiceKey: "inventoryitem").Result);
 
                 //inventoryitem has unlimited items available
                 Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, null, null, null, null, "noninventoryitem").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, choiceKey: "noninventoryitem").Result);
                 Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, null, null, null, null, "noninventoryitem").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, choiceKey: "noninventoryitem").Result);
 
                 //verify invoices where created
                 invoices = user.BitPay.GetInvoices();
@@ -777,15 +784,13 @@ noninventoryitem:
 
                 //let's mark the inventoryitem invoice as invalid, this should return the item to back in stock
                 var controller = tester.PayTester.GetController<UIInvoiceController>(user.UserId, user.StoreId);
-                var appService = tester.PayTester.GetService<AppService>();
-                var eventAggregator = tester.PayTester.GetService<EventAggregator>();
                 Assert.IsType<JsonResult>(await controller.ChangeInvoiceState(inventoryItemInvoice.Id, "invalid"));
                 //check that item is back in stock
                 await TestUtils.EventuallyAsync(async () =>
                 {
                     vmpos = await pos.UpdatePointOfSale(app.Id).AssertViewModelAsync<UpdatePointOfSaleViewModel>();
                     Assert.Equal(1,
-                        appService.Parse(vmpos.Template, "BTC").Single(item => item.Id == "inventoryitem").Inventory);
+                        AppService.Parse(vmpos.Template).Single(item => item.Id == "inventoryitem").Inventory);
                 }, 10000);
 
                 //test payment methods option
@@ -800,11 +805,13 @@ btconly:
     - BTC
 normal:
   price: 1.0";
+
+                vmpos.Template = AppService.SerializeTemplate(MigrationStartupTask.ParsePOSYML(vmpos.Template));
                 Assert.IsType<RedirectToActionResult>(pos.UpdatePointOfSale(app.Id, vmpos).Result);
                 Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, null, null, null, null, "btconly").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, choiceKey: "btconly").Result);
                 Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, null, null, null, null, "normal").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, choiceKey: "normal").Result);
                 invoices = user.BitPay.GetInvoices();
                 var normalInvoice = invoices.Single(invoice => invoice.ItemCode == "normal");
                 var btcOnlyInvoice = invoices.Single(invoice => invoice.ItemCode == "btconly");
@@ -819,13 +826,13 @@ normal:
                     normalInvoice.CryptoInfo,
                     s => PaymentTypes.BTCLike.ToString() == s.PaymentType && new[] { "BTC", "LTC" }.Contains(
                              s.CryptoCode));
-                
+
                 //test topup option
                 vmpos.Template = @"
 a:
   price: 1000.0
   title: good apple
-  
+
 b:
   price: 10.0
   custom: false
@@ -843,21 +850,22 @@ f:
 g:
   custom: topup
 ";
-                
+
+                vmpos.Template = AppService.SerializeTemplate(MigrationStartupTask.ParsePOSYML(vmpos.Template));
                 Assert.IsType<RedirectToActionResult>(pos.UpdatePointOfSale(app.Id, vmpos).Result);
                 vmpos = await pos.UpdatePointOfSale(app.Id).AssertViewModelAsync<UpdatePointOfSaleViewModel>();
                 Assert.DoesNotContain("custom", vmpos.Template);
-                var items = appService.Parse(vmpos.Template, vmpos.Currency);
-                Assert.Contains(items, item => item.Id == "a" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "b" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "c" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Minimum);
-                Assert.Contains(items, item => item.Id == "d" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "e" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Minimum);
-                Assert.Contains(items, item => item.Id == "f" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Topup);
-                Assert.Contains(items, item => item.Id == "g" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Topup);
+                var items = AppService.Parse(vmpos.Template);
+                Assert.Contains(items, item => item.Id == "a" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Fixed);
+                Assert.Contains(items, item => item.Id == "b" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Fixed);
+                Assert.Contains(items, item => item.Id == "c" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Minimum);
+                Assert.Contains(items, item => item.Id == "d" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Fixed);
+                Assert.Contains(items, item => item.Id == "e" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Minimum);
+                Assert.Contains(items, item => item.Id == "f" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Topup);
+                Assert.Contains(items, item => item.Id == "g" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Topup);
                 
                 Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Static, null, null, null, null, null, "g").Result);
+                    .ViewPointOfSale(app.Id, PosViewType.Static, choiceKey: "g").Result);
                 invoices = user.BitPay.GetInvoices();
                 var topupInvoice = invoices.Single(invoice => invoice.ItemCode == "g");
                 Assert.Equal(0, topupInvoice.Price);

BTCPayServer.Tests/ApiKeysTests.cs

@@ -286,7 +286,7 @@ namespace BTCPayServer.Tests
             if (permissions.Contains(canModifyAllStores) || storePermissions.Any())
             {
                 var resultStores =
-                    await TestApiAgainstAccessToken<StoreData[]>(accessToken, $"{TestApiPath}/me/stores",
+                    await TestApiAgainstAccessToken<Client.Models.StoreData[]>(accessToken, $"{TestApiPath}/me/stores",
                         tester.PayTester.HttpClient);
 
                 foreach (var selectiveStorePermission in storePermissions)

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -23,7 +23,7 @@
     <PackageReference Include="Newtonsoft.Json.Schema" Version="3.0.14" />
     <PackageReference Include="Selenium.Support" Version="4.1.1" />
     <PackageReference Include="Selenium.WebDriver" Version="4.1.1" />
-    <PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="110.0.5481.7700" />
+    <PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="114.0.5735.9000" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
       <PrivateAssets>all</PrivateAssets>

BTCPayServer.Tests/CheckoutUITests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
 using BTCPayServer.Payments;
 using BTCPayServer.Tests.Logging;
 using BTCPayServer.Views.Stores;
@@ -27,6 +28,7 @@ namespace BTCPayServer.Tests
             s.GoToRegister();
             s.RegisterNewUser();
             s.CreateNewStore();
+            s.EnableCheckout(CheckoutType.V1);
             s.AddDerivationScheme();
             s.GoToStore(StoreNavPages.CheckoutAppearance);
             s.Driver.FindElement(By.Id("RequiresRefundEmail")).Click();
@@ -72,6 +74,7 @@ namespace BTCPayServer.Tests
             s.GoToRegister();
             s.RegisterNewUser();
             s.CreateNewStore();
+            s.EnableCheckout(CheckoutType.V1);
             s.AddDerivationScheme();
 
             // Now create an invoice that requires a refund email
@@ -124,6 +127,7 @@ namespace BTCPayServer.Tests
             s.GoToRegister();
             s.RegisterNewUser();
             s.CreateNewStore();
+            s.EnableCheckout(CheckoutType.V1);
             s.AddDerivationScheme();
 
             var invoiceId = s.CreateInvoice();
@@ -154,13 +158,13 @@ namespace BTCPayServer.Tests
             s.GoToRegister();
             s.RegisterNewUser(true);
             s.CreateNewStore();
+            s.EnableCheckout(CheckoutType.V1);
             s.AddLightningNode();
             s.AddDerivationScheme();
 
             var invoiceId = s.CreateInvoice(defaultPaymentMethod: "BTC_LightningLike");
             s.GoToInvoiceCheckout(invoiceId);
-
-            Assert.Equal("Bitcoin (Lightning) (BTC)", s.Driver.FindElement(By.ClassName("payment__currencies")).Text);
+            Assert.Equal("Bitcoin (Lightning)", s.Driver.FindElement(By.ClassName("payment__currencies")).Text);
             s.Driver.Quit();
         }
 
@@ -174,6 +178,7 @@ namespace BTCPayServer.Tests
             s.GoToRegister();
             s.RegisterNewUser(true);
             s.CreateNewStore();
+            s.EnableCheckout(CheckoutType.V1);
             s.AddLightningNode();
             s.GoToLightningSettings();
             s.Driver.SetCheckbox(By.Id("LightningAmountInSatoshi"), true);
@@ -182,7 +187,7 @@ namespace BTCPayServer.Tests
 
             var invoiceId = s.CreateInvoice(10, "USD", "a@g.com");
             s.GoToInvoiceCheckout(invoiceId);
-            Assert.Contains("Sats", s.Driver.FindElement(By.ClassName("payment__currencies_noborder")).Text);
+            Assert.Contains("sats", s.Driver.FindElement(By.ClassName("buyerTotalLine")).Text);
         }
 
         [Fact(Timeout = TestTimeout)]
@@ -193,6 +198,7 @@ namespace BTCPayServer.Tests
             s.GoToRegister();
             s.RegisterNewUser();
             s.CreateNewStore();
+            s.EnableCheckout(CheckoutType.V1);
             s.GoToStore();
             s.AddDerivationScheme();
             var invoiceId = s.CreateInvoice(0.001m, "BTC", "a@x.com");

BTCPayServer.Tests/Checkoutv2Tests.cs

@@ -1,8 +1,6 @@
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Payments;
-using BTCPayServer.Tests.Logging;
 using BTCPayServer.Views.Stores;
 using NBitcoin;
 using OpenQA.Selenium;
@@ -32,26 +30,26 @@ namespace BTCPayServer.Tests
             s.GoToRegister();
             s.RegisterNewUser(true);
             s.CreateNewStore();
-            s.EnableCheckoutV2();
             s.AddLightningNode();
             // Use non-legacy derivation scheme
             s.AddDerivationScheme("BTC", "tpubDD79XF4pzhmPSJ9AyUay9YbXAeD1c6nkUqC32pnKARJH6Ja5hGUfGc76V82ahXpsKqN6UcSGXMkzR34aZq4W23C6DAdZFaVrzWqzj24F8BC");
 
             // Configure store url
             var storeUrl = "https://satoshisteaks.com/";
+            var supportUrl = "https://support.satoshisteaks.com/{InvoiceId}/";
             s.GoToStore();
             s.Driver.FindElement(By.Id("StoreWebsite")).SendKeys(storeUrl);
+            s.Driver.FindElement(By.Id("StoreSupportUrl")).SendKeys(supportUrl);
             s.Driver.FindElement(By.Id("Save")).Click();
             Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
-            
-            // Enable LNURL, which we will need for (non-)presence checks throughout this test
-            s.GoToHome();
-            s.GoToLightningSettings();
-            s.Driver.SetCheckbox(By.Id("LNURLEnabled"), true);
-            s.Driver.SetCheckbox(By.Id("LNURLStandardInvoiceEnabled"), true);
-            s.Driver.FindElement(By.Id("save")).Click();
-            Assert.Contains("BTC Lightning settings successfully updated", s.FindAlertMessage().Text);
-            
+
+            s.GoToStore(StoreNavPages.CheckoutAppearance);
+            s.Driver.WaitForAndClick(By.Id("Presets"));
+            s.Driver.WaitForAndClick(By.Id("Presets_InStore"));
+            Assert.True(s.Driver.SetCheckbox(By.Id("ShowPayInWalletButton"), true));
+            s.Driver.FindElement(By.Id("Save")).SendKeys(Keys.Enter);
+            Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
+
             // Top up/zero amount invoices
             var invoiceId = s.CreateInvoice(amount: null);
             s.GoToInvoiceCheckout(invoiceId);
@@ -64,29 +62,35 @@ namespace BTCPayServer.Tests
             var qrValue = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-qr-value");
             var address = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
             var payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
-            var copyAddress = s.Driver.FindElement(By.Id("Address_BTC")).GetAttribute("value");
+            var copyAddress = s.Driver.FindElement(By.CssSelector("#Address_BTC .truncate-center-start")).Text;
             Assert.Equal($"bitcoin:{address}", payUrl);
-            Assert.StartsWith("bcrt", s.Driver.FindElement(By.Id("Address_BTC")).GetAttribute("value"));
+            Assert.StartsWith("bcrt", s.Driver.FindElement(By.CssSelector("#Address_BTC .truncate-center-start")).Text);
             Assert.DoesNotContain("lightning=", payUrl);
             Assert.Equal(address, copyAddress);
             Assert.Equal($"bitcoin:{address.ToUpperInvariant()}", qrValue);
             s.Driver.ElementDoesNotExist(By.Id("Lightning_BTC"));
-            s.Driver.ElementDoesNotExist(By.Id("PayByLNURL"));
-            
+
+            // Details should show exchange rate
+            s.Driver.ToggleCollapse("PaymentDetails");
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-TotalPrice"));
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-TotalFiat"));
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-AmountDue"));
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("sat/byte", s.Driver.FindElement(By.Id("PaymentDetails-RecommendedFee")).Text);
+
             // Switch to LNURL
             s.Driver.FindElement(By.CssSelector(".payment-method:nth-child(2)")).Click();
             TestUtils.Eventually(() =>
             {
                 payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
                 Assert.StartsWith("lightning:lnurl", payUrl);
-                Assert.StartsWith("lnurl", s.Driver.WaitForElement(By.Id("Lightning_BTC")).GetAttribute("value"));
+                Assert.StartsWith("lnurl", s.Driver.WaitForElement(By.CssSelector("#Lightning_BTC .truncate-center-start")).Text);
                 s.Driver.ElementDoesNotExist(By.Id("Address_BTC"));
-                s.Driver.FindElement(By.Id("PayByLNURL"));
             });
 
             // Default payment method
             s.GoToHome();
-            invoiceId = s.CreateInvoice(defaultPaymentMethod: "BTC_LightningLike");
+            invoiceId = s.CreateInvoice(21000, "SATS", defaultPaymentMethod: "BTC_LightningLike");
             s.GoToInvoiceCheckout(invoiceId);
             s.Driver.WaitUntilAvailable(By.Id("Checkout-v2"));
             Assert.Equal(2, s.Driver.FindElements(By.CssSelector(".payment-method")).Count);
@@ -95,14 +99,13 @@ namespace BTCPayServer.Tests
             qrValue = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-qr-value");
             address = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
             payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
-            copyAddress = s.Driver.FindElement(By.Id("Lightning_BTC_LightningLike")).GetAttribute("value");
+            copyAddress = s.Driver.FindElement(By.CssSelector("#Lightning_BTC_LightningLike .truncate-center-start")).Text;
             Assert.Equal($"lightning:{address}", payUrl);
             Assert.Equal(address, copyAddress);
             Assert.Equal($"lightning:{address.ToUpperInvariant()}", qrValue);
             s.Driver.ElementDoesNotExist(By.Id("Address_BTC"));
-            s.Driver.FindElement(By.Id("PayByLNURL"));
 
-            // Lightning amount in Sats
+            // Lightning amount in sats
             Assert.Contains("BTC", s.Driver.FindElement(By.Id("AmountDue")).Text);
             s.GoToHome();
             s.GoToLightningSettings();
@@ -111,7 +114,15 @@ namespace BTCPayServer.Tests
             Assert.Contains("BTC Lightning settings successfully updated", s.FindAlertMessage().Text);
             s.GoToInvoiceCheckout(invoiceId);
             s.Driver.WaitUntilAvailable(By.Id("Checkout-v2"));
-            Assert.Contains("Sats", s.Driver.FindElement(By.Id("AmountDue")).Text);
+            Assert.Contains("sats", s.Driver.FindElement(By.Id("AmountDue")).Text);
+
+            // Details should not show exchange rate
+            s.Driver.ToggleCollapse("PaymentDetails");
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-ExchangeRate"));
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-TotalFiat"));
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-RecommendedFee"));
+            Assert.Contains("21 000 sats", s.Driver.FindElement(By.Id("PaymentDetails-AmountDue")).Text);
+            Assert.Contains("21 000 sats", s.Driver.FindElement(By.Id("PaymentDetails-TotalPrice")).Text);
 
             // Expire
             var expirySeconds = s.Driver.FindElement(By.Id("ExpirySeconds"));
@@ -124,10 +135,49 @@ namespace BTCPayServer.Tests
             Assert.DoesNotContain("Please send", paymentInfo.Text);
             TestUtils.Eventually(() =>
             {
-                var expiredSection = s.Driver.FindElement(By.Id("expired"));
+                var expiredSection = s.Driver.FindElement(By.Id("unpaid"));
                 Assert.True(expiredSection.Displayed);
                 Assert.Contains("Invoice Expired", expiredSection.Text);
+                Assert.Contains("resubmit a payment", expiredSection.Text);
+                Assert.DoesNotContain("This invoice expired with partial payment", expiredSection.Text);
+                
             });
+            Assert.True(s.Driver.ElementDoesNotExist(By.Id("ContactLink")));
+            Assert.True(s.Driver.ElementDoesNotExist(By.Id("ReceiptLink")));
+            Assert.Equal(storeUrl, s.Driver.FindElement(By.Id("StoreLink")).GetAttribute("href"));
+
+            // Expire paid partial
+            s.GoToHome();
+            invoiceId = s.CreateInvoice(2100, "EUR");
+            s.GoToInvoiceCheckout(invoiceId);
+            s.Driver.WaitUntilAvailable(By.Id("Checkout-v2"));
+            
+            await Task.Delay(200);
+            address = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
+            var amountFraction = "0.00001";
+            await s.Server.ExplorerNode.SendToAddressAsync(BitcoinAddress.Create(address, Network.RegTest),
+                Money.Parse(amountFraction));
+            await s.Server.ExplorerNode.GenerateAsync(1);
+            
+            expirySeconds = s.Driver.FindElement(By.Id("ExpirySeconds"));
+            expirySeconds.Clear();
+            expirySeconds.SendKeys("3");
+            s.Driver.FindElement(By.Id("Expire")).Click();
+
+            paymentInfo = s.Driver.WaitForElement(By.Id("PaymentInfo"));
+            Assert.Contains("The invoice hasn't been paid in full.", paymentInfo.Text);
+            Assert.Contains("Please send", paymentInfo.Text);
+            TestUtils.Eventually(() =>
+            {
+                var expiredSection = s.Driver.FindElement(By.Id("unpaid"));
+                Assert.True(expiredSection.Displayed);
+                Assert.Contains("Invoice Expired", expiredSection.Text);
+                Assert.Contains("This invoice expired with partial payment", expiredSection.Text);
+                Assert.DoesNotContain("resubmit a payment", expiredSection.Text);
+            });
+            var contactLink = s.Driver.FindElement(By.Id("ContactLink"));
+            Assert.Equal("Contact us", contactLink.Text);
+            Assert.Matches(supportUrl.Replace("{InvoiceId}", invoiceId), contactLink.GetAttribute("href"));
             Assert.True(s.Driver.ElementDoesNotExist(By.Id("ReceiptLink")));
             Assert.Equal(storeUrl, s.Driver.FindElement(By.Id("StoreLink")).GetAttribute("href"));
 
@@ -145,54 +195,67 @@ namespace BTCPayServer.Tests
             Assert.Contains("Exchange Rate", details.Text);
             Assert.Contains("Amount Due", details.Text);
             Assert.Contains("Recommended Fee", details.Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-TotalFiat")).Text);
+            Assert.Contains("BTC", s.Driver.FindElement(By.Id("PaymentDetails-AmountDue")).Text);
+            Assert.Contains("BTC", s.Driver.FindElement(By.Id("PaymentDetails-TotalPrice")).Text);
 
             // Pay partial amount
             await Task.Delay(200);
             address = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
-            var amountFraction = "0.00001";
+            amountFraction = "0.00001";
             await s.Server.ExplorerNode.SendToAddressAsync(BitcoinAddress.Create(address, Network.RegTest),
                 Money.Parse(amountFraction));
             await s.Server.ExplorerNode.GenerateAsync(1);
 
             // Fake Pay
-            s.Driver.FindElement(By.Id("FakePayAmount")).FillIn(amountFraction);
-            s.Driver.FindElement(By.Id("FakePay")).Click();
             TestUtils.Eventually(() =>
             {
-                Assert.Contains("Created transaction",
-                    s.Driver.WaitForElement(By.Id("CheatSuccessMessage")).Text);
-                s.Server.ExplorerNode.Generate(1);
                 paymentInfo = s.Driver.WaitForElement(By.Id("PaymentInfo"));
                 Assert.Contains("The invoice hasn't been paid in full", paymentInfo.Text);
                 Assert.Contains("Please send", paymentInfo.Text);
             });
 
+            s.Driver.Navigate().Refresh();
+
+            // Pay full amount
+            s.PayInvoice();
+
+            // Processing
+            TestUtils.Eventually(() =>
+            {
+                var processingSection = s.Driver.WaitForElement(By.Id("processing"));
+                Assert.True(processingSection.Displayed);
+                Assert.Contains("Payment Received", processingSection.Text);
+                Assert.Contains("Your payment has been received and is now processing", processingSection.Text);
+            });
+            s.Driver.FindElement(By.Id("confetti"));
+
             // Mine
-            s.Driver.FindElement(By.Id("Mine")).Click();
+            s.MineBlockOnInvoiceCheckout();
             TestUtils.Eventually(() =>
             {
                 Assert.Contains("Mined 1 block",
                     s.Driver.WaitForElement(By.Id("CheatSuccessMessage")).Text);
             });
 
-            // Pay full amount
-            var amountDue = s.Driver.FindElement(By.Id("AmountDue")).GetAttribute("data-amount-due");
-            s.Driver.FindElement(By.Id("FakePayAmount")).FillIn(amountDue);
-            s.Driver.FindElement(By.Id("FakePay")).Click();
+            // Settled
             TestUtils.Eventually(() =>
             {
-                s.Server.ExplorerNode.Generate(1);
-                var paidSection = s.Driver.WaitForElement(By.Id("paid"));
-                Assert.True(paidSection.Displayed);
-                Assert.Contains("Invoice Paid", paidSection.Text);
+                var settledSection = s.Driver.WaitForElement(By.Id("settled"));
+                Assert.True(settledSection.Displayed);
+                Assert.Contains("Invoice Paid", settledSection.Text);
             });
+            s.Driver.FindElement(By.Id("confetti"));
             s.Driver.FindElement(By.Id("ReceiptLink"));
+            Assert.True(s.Driver.ElementDoesNotExist(By.Id("ContactLink")));
             Assert.Equal(storeUrl, s.Driver.FindElement(By.Id("StoreLink")).GetAttribute("href"));
 
             // BIP21
             s.GoToHome();
             s.GoToStore(StoreNavPages.CheckoutAppearance);
             s.Driver.SetCheckbox(By.Id("OnChainWithLnInvoiceFallback"), true);
+            s.Driver.SetCheckbox(By.Id("LightningAmountInSatoshi"), false);
             s.Driver.FindElement(By.Id("Save")).Click();
             Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
 
@@ -200,11 +263,12 @@ namespace BTCPayServer.Tests
             s.GoToInvoiceCheckout(invoiceId);
             s.Driver.WaitUntilAvailable(By.Id("Checkout-v2"));
             Assert.Empty(s.Driver.FindElements(By.CssSelector(".payment-method")));
+            Assert.Contains("BTC", s.Driver.FindElement(By.Id("AmountDue")).Text);
             qrValue = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-qr-value");
             address = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
             payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
-            var copyAddressOnchain = s.Driver.FindElement(By.Id("Address_BTC")).GetAttribute("value");
-            var copyAddressLightning = s.Driver.FindElement(By.Id("Lightning_BTC")).GetAttribute("value");
+            var copyAddressOnchain = s.Driver.FindElement(By.CssSelector("#Address_BTC .truncate-center-start")).Text;
+            var copyAddressLightning = s.Driver.FindElement(By.CssSelector("#Lightning_BTC .truncate-center-start")).Text;
             Assert.StartsWith($"bitcoin:{address}?amount=", payUrl);
             Assert.Contains("?amount=", payUrl);
             Assert.Contains("&lightning=", payUrl);
@@ -213,7 +277,32 @@ namespace BTCPayServer.Tests
             Assert.StartsWith("lnbcrt", copyAddressLightning);
             Assert.StartsWith($"bitcoin:{address.ToUpperInvariant()}?amount=", qrValue);
             Assert.Contains("&lightning=LNBCRT", qrValue);
-            s.Driver.FindElement(By.Id("PayByLNURL"));
+
+            // Check details
+            s.Driver.ToggleCollapse("PaymentDetails");
+            Assert.Contains("1 BTC = ", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-TotalFiat")).Text);
+            Assert.Contains("BTC", s.Driver.FindElement(By.Id("PaymentDetails-AmountDue")).Text);
+            Assert.Contains("BTC", s.Driver.FindElement(By.Id("PaymentDetails-TotalPrice")).Text);
+
+            // Switch to amount displayed in sats
+            s.GoToHome();
+            s.GoToStore(StoreNavPages.CheckoutAppearance);
+            s.Driver.SetCheckbox(By.Id("LightningAmountInSatoshi"), true);
+            s.Driver.FindElement(By.Id("Save")).Click();
+            Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
+            s.GoToInvoiceCheckout(invoiceId);
+            s.Driver.WaitUntilAvailable(By.Id("Checkout-v2"));
+            Assert.Contains("sats", s.Driver.FindElement(By.Id("AmountDue")).Text);
+
+            // Check details
+            s.Driver.ToggleCollapse("PaymentDetails");
+            Assert.Contains("1 sat = ", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-TotalFiat")).Text);
+            Assert.Contains("sats", s.Driver.FindElement(By.Id("PaymentDetails-AmountDue")).Text);
+            Assert.Contains("sats", s.Driver.FindElement(By.Id("PaymentDetails-TotalPrice")).Text);
 
             // BIP21 with LN as default payment method
             s.GoToHome();
@@ -224,14 +313,20 @@ namespace BTCPayServer.Tests
             payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
             Assert.StartsWith("bitcoin:", payUrl);
             Assert.Contains("&lightning=lnbcrt", payUrl);
-            s.Driver.FindElement(By.Id("PayByLNURL"));
+
+            // Check details
+            s.Driver.ToggleCollapse("PaymentDetails");
+            Assert.Contains("1 sat = ", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-TotalFiat")).Text);
+            Assert.Contains("sats", s.Driver.FindElement(By.Id("PaymentDetails-AmountDue")).Text);
+            Assert.Contains("sats", s.Driver.FindElement(By.Id("PaymentDetails-TotalPrice")).Text);
 
             // Ensure LNURL is enabled
             s.GoToHome();
             s.GoToLightningSettings();
             Assert.True(s.Driver.FindElement(By.Id("LNURLEnabled")).Selected);
-            Assert.True(s.Driver.FindElement(By.Id("LNURLStandardInvoiceEnabled")).Selected);
-            
+
             // BIP21 with top-up invoice
             invoiceId = s.CreateInvoice(amount: null);
             s.GoToInvoiceCheckout(invoiceId);
@@ -240,8 +335,8 @@ namespace BTCPayServer.Tests
             qrValue = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-qr-value");
             address = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
             payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
-            copyAddressOnchain = s.Driver.FindElement(By.Id("Address_BTC")).GetAttribute("value");
-            copyAddressLightning = s.Driver.FindElement(By.Id("Lightning_BTC")).GetAttribute("value");
+            copyAddressOnchain = s.Driver.FindElement(By.CssSelector("#Address_BTC .truncate-center-start")).Text;
+            copyAddressLightning = s.Driver.FindElement(By.CssSelector("#Lightning_BTC .truncate-center-start")).Text;
             Assert.StartsWith($"bitcoin:{address}", payUrl);
             Assert.Contains("?lightning=lnurl", payUrl);
             Assert.DoesNotContain("amount=", payUrl);
@@ -249,7 +344,14 @@ namespace BTCPayServer.Tests
             Assert.Equal(address, copyAddressOnchain);
             Assert.StartsWith("lnurl", copyAddressLightning);
             Assert.StartsWith($"bitcoin:{address.ToUpperInvariant()}?lightning=LNURL", qrValue);
-            s.Driver.FindElement(By.Id("PayByLNURL"));
+
+            // Check details
+            s.Driver.ToggleCollapse("PaymentDetails");
+            Assert.Contains("1 sat = ", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            Assert.Contains("$", s.Driver.FindElement(By.Id("PaymentDetails-ExchangeRate")).Text);
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-TotalFiat"));
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-AmountDue"));
+            s.Driver.ElementDoesNotExist(By.Id("PaymentDetails-TotalPrice"));
 
             // Expiry message should not show amount for top-up invoice
             expirySeconds = s.Driver.FindElement(By.Id("ExpirySeconds"));
@@ -261,7 +363,7 @@ namespace BTCPayServer.Tests
             Assert.Contains("This invoice will expire in", paymentInfo.Text);
             Assert.Contains("00:0", paymentInfo.Text);
             Assert.DoesNotContain("Please send", paymentInfo.Text);
-            
+
             // Configure countdown timer
             s.GoToHome();
             invoiceId = s.CreateInvoice();
@@ -273,13 +375,13 @@ namespace BTCPayServer.Tests
             displayExpirationTimer.SendKeys("10");
             s.Driver.FindElement(By.Id("Save")).Click();
             Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
-            
+
             s.GoToInvoiceCheckout(invoiceId);
             s.Driver.WaitUntilAvailable(By.Id("Checkout-v2"));
             paymentInfo = s.Driver.FindElement(By.Id("PaymentInfo"));
             Assert.False(paymentInfo.Displayed);
             Assert.DoesNotContain("This invoice will expire in", paymentInfo.Text);
-            
+
             expirySeconds = s.Driver.FindElement(By.Id("ExpirySeconds"));
             expirySeconds.Clear();
             expirySeconds.SendKeys("599");
@@ -289,11 +391,12 @@ namespace BTCPayServer.Tests
             Assert.True(paymentInfo.Displayed);
             Assert.Contains("This invoice will expire in", paymentInfo.Text);
             Assert.Contains("09:5", paymentInfo.Text);
-            
+
             // Disable LNURL again
             s.GoToHome();
             s.GoToLightningSettings();
             s.Driver.SetCheckbox(By.Id("LNURLEnabled"), false);
+            s.Driver.ScrollTo(By.Id("save"));
             s.Driver.FindElement(By.Id("save")).Click();
             Assert.Contains("BTC Lightning settings successfully updated", s.FindAlertMessage().Text);
 
@@ -308,8 +411,7 @@ namespace BTCPayServer.Tests
             payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
             Assert.StartsWith("bitcoin:", payUrl);
             Assert.Contains("&lightning=lnbcrt", payUrl);
-            s.Driver.FindElement(By.Id("PayByLNURL"));
-            
+
             // Language Switch
             var languageSelect = new SelectElement(s.Driver.FindElement(By.Id("DefaultLang")));
             Assert.Equal("English", languageSelect.SelectedOption.Text);
@@ -318,9 +420,9 @@ namespace BTCPayServer.Tests
             languageSelect.SelectByText("Deutsch");
             Assert.Equal("Details anzeigen", s.Driver.FindElement(By.Id("DetailsToggle")).Text);
             Assert.Contains("lang=de", s.Driver.Url);
-            
+
             s.Driver.Navigate().Refresh();
-            languageSelect = new SelectElement(s.Driver.FindElement(By.Id("DefaultLang")));
+            languageSelect = new SelectElement(s.Driver.WaitForElement(By.Id("DefaultLang")));
             Assert.Equal("Deutsch", languageSelect.SelectedOption.Text);
             Assert.Equal("Details anzeigen", s.Driver.FindElement(By.Id("DetailsToggle")).Text);
             languageSelect.SelectByText("English");
@@ -336,7 +438,6 @@ namespace BTCPayServer.Tests
             s.GoToRegister();
             s.RegisterNewUser();
             s.CreateNewStore();
-            s.EnableCheckoutV2();
             s.GoToStore();
             s.AddDerivationScheme();
             var invoiceId = s.CreateInvoice(0.001m, "BTC", "a@x.com");

BTCPayServer.Tests/CrowdfundTests.cs

@@ -1,14 +1,15 @@
 using System;
 using System.Threading.Tasks;
+using BTCPayServer.Client;
 using BTCPayServer.Client.Models;
 using BTCPayServer.Controllers;
 using BTCPayServer.Data;
 using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Plugins.Crowdfund;
 using BTCPayServer.Plugins.Crowdfund.Controllers;
 using BTCPayServer.Plugins.Crowdfund.Models;
 using BTCPayServer.Services.Apps;
 using BTCPayServer.Services.Invoices;
-using BTCPayServer.Tests.Logging;
 using Microsoft.AspNetCore.Mvc;
 using NBitcoin;
 using NBitpayClient;
@@ -34,18 +35,16 @@ namespace BTCPayServer.Tests
             await user.GrantAccessAsync();
             var user2 = tester.NewAccount();
             await user2.GrantAccessAsync();
-            var stores = user.GetController<UIStoresController>();
             var apps = user.GetController<UIAppsController>();
             var apps2 = user2.GetController<UIAppsController>();
             var crowdfund = user.GetController<UICrowdfundController>();
-            var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp(user.StoreId)).Model);
-            var appType = AppType.Crowdfund.ToString();
-            Assert.NotNull(vm.SelectedAppType);
+            var appType = CrowdfundAppType.AppType;
+            var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp(user.StoreId, appType)).Model);
+            Assert.Equal(appType, vm.SelectedAppType);
             Assert.Null(vm.AppName);
             vm.AppName = "test";
-            vm.SelectedAppType = appType;
-            var redirectToAction = Assert.IsType<RedirectToActionResult>(apps.CreateApp(user.StoreId, vm).Result);
-            Assert.Equal(nameof(crowdfund.UpdateCrowdfund), redirectToAction.ActionName);
+            var redirect = Assert.IsType<RedirectResult>(apps.CreateApp(user.StoreId, vm).Result);
+            Assert.EndsWith("/settings/crowdfund", redirect.Url);
             var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps(user.StoreId).Result).Model);
             var app = appList.Apps[0];
             var appData = new AppData { Id = app.Id, StoreDataId = app.StoreId, Name = app.AppName, AppType = appType };
@@ -57,12 +56,12 @@ namespace BTCPayServer.Tests
             Assert.Empty(appList2.Apps);
             Assert.Equal("test", appList.Apps[0].AppName);
             Assert.Equal(apps.CreatedAppId, appList.Apps[0].Id);
-            Assert.True(appList.Apps[0].IsOwner);
+            Assert.True(appList.Apps[0].Role.ToPermissionSet(appList.Apps[0].StoreId).Contains(Policies.CanModifyStoreSettings, appList.Apps[0].StoreId));
             Assert.Equal(user.StoreId, appList.Apps[0].StoreId);
             Assert.IsType<NotFoundResult>(apps2.DeleteApp(appList.Apps[0].Id));
             Assert.IsType<ViewResult>(apps.DeleteApp(appList.Apps[0].Id));
-            redirectToAction = Assert.IsType<RedirectToActionResult>(apps.DeleteAppPost(appList.Apps[0].Id).Result);
-            Assert.Equal(nameof(stores.Dashboard), redirectToAction.ActionName);
+            var redirectToAction = Assert.IsType<RedirectToActionResult>(apps.DeleteAppPost(appList.Apps[0].Id).Result);
+            Assert.Equal(nameof(UIStoresController.Dashboard), redirectToAction.ActionName);
             appList = await apps.ListApps(user.StoreId).AssertViewModelAsync<ListAppsViewModel>();
             Assert.Empty(appList.Apps);
         }
@@ -79,10 +78,11 @@ namespace BTCPayServer.Tests
             var apps = user.GetController<UIAppsController>();
             var crowdfund = user.GetController<UICrowdfundController>();
             var vm = apps.CreateApp(user.StoreId).AssertViewModel<CreateAppViewModel>();
-            var appType = AppType.Crowdfund.ToString();
+            var appType = CrowdfundAppType.AppType;
             vm.AppName = "test";
             vm.SelectedAppType = appType;
-            Assert.IsType<RedirectToActionResult>(apps.CreateApp(user.StoreId, vm).Result);
+            var redirect = Assert.IsType<RedirectResult>(apps.CreateApp(user.StoreId, vm).Result);
+            Assert.EndsWith("/settings/crowdfund", redirect.Url);
             var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps(user.StoreId).Result).Model);
             var app = appList.Apps[0];
             var appData = new AppData { Id = app.Id, StoreDataId = app.StoreId, Name = app.AppName, AppType = appType };
@@ -105,7 +105,7 @@ namespace BTCPayServer.Tests
                 Amount = new decimal(0.01)
             }, default));
 
-            Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(app.Id, string.Empty));
+            Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(app.Id));
 
             //Scenario 2: Not Enabled But Admin - Allowed
             Assert.IsType<OkObjectResult>(await crowdfundController.ContributeToCrowdfund(app.Id, new ContributeToCrowdfund()
@@ -113,8 +113,8 @@ namespace BTCPayServer.Tests
                 RedirectToCheckout = false,
                 Amount = new decimal(0.01)
             }, default));
-            Assert.IsType<ViewResult>(await crowdfundController.ViewCrowdfund(app.Id, string.Empty));
-            Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(app.Id, string.Empty));
+            Assert.IsType<ViewResult>(await crowdfundController.ViewCrowdfund(app.Id));
+            Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(app.Id));
 
             //Scenario 3: Enabled But Start Date > Now - Not Allowed
             crowdfundViewModel.StartDate = DateTime.Today.AddDays(2);
@@ -170,10 +170,10 @@ namespace BTCPayServer.Tests
             var apps = user.GetController<UIAppsController>();
             var crowdfund = user.GetController<UICrowdfundController>();
             var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp(user.StoreId)).Model);
-            var appType = AppType.Crowdfund.ToString();
+            var appType = CrowdfundAppType.AppType;
             vm.AppName = "test";
             vm.SelectedAppType = appType;
-            Assert.IsType<RedirectToActionResult>(apps.CreateApp(user.StoreId, vm).Result);
+            Assert.IsType<RedirectResult>(apps.CreateApp(user.StoreId, vm).Result);
             var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps(user.StoreId).Result).Model);
             var app = appList.Apps[0];
             var appData = new AppData { Id = app.Id, StoreDataId = app.StoreId, Name = app.AppName, AppType = appType };
@@ -193,7 +193,7 @@ namespace BTCPayServer.Tests
             var publicApps = user.GetController<UICrowdfundController>();
 
             var model = Assert.IsType<ViewCrowdfundViewModel>(Assert
-                .IsType<ViewResult>(publicApps.ViewCrowdfund(app.Id, String.Empty).Result).Model);
+                .IsType<ViewResult>(publicApps.ViewCrowdfund(app.Id).Result).Model);
 
             Assert.Equal(crowdfundViewModel.TargetAmount, model.TargetAmount);
             Assert.Equal(crowdfundViewModel.EndDate, model.EndDate);
@@ -217,7 +217,7 @@ namespace BTCPayServer.Tests
             }, Facade.Merchant);
 
             model = Assert.IsType<ViewCrowdfundViewModel>(Assert
-                .IsType<ViewResult>(publicApps.ViewCrowdfund(app.Id, string.Empty).Result).Model);
+                .IsType<ViewResult>(publicApps.ViewCrowdfund(app.Id).Result).Model);
 
             Assert.Equal(0m, model.Info.CurrentAmount);
             Assert.Equal(1m, model.Info.CurrentPendingAmount);
@@ -226,12 +226,12 @@ namespace BTCPayServer.Tests
 
             TestLogs.LogInformation("Let's check current amount change once payment is confirmed");
             var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
-            tester.ExplorerNode.SendToAddress(invoiceAddress, invoice.BtcDue);
-            tester.ExplorerNode.Generate(1); // By default invoice confirmed at 1 block
+            await tester.ExplorerNode.SendToAddressAsync(invoiceAddress, invoice.BtcDue);
+            await tester.ExplorerNode.GenerateAsync(1); // By default invoice confirmed at 1 block
             TestUtils.Eventually(() =>
             {
                 model = Assert.IsType<ViewCrowdfundViewModel>(Assert
-                .IsType<ViewResult>(publicApps.ViewCrowdfund(app.Id, String.Empty).Result).Model);
+                .IsType<ViewResult>(publicApps.ViewCrowdfund(app.Id).Result).Model);
                 Assert.Equal(1m, model.Info.CurrentAmount);
                 Assert.Equal(0m, model.Info.CurrentPendingAmount);
             });
@@ -279,7 +279,7 @@ namespace BTCPayServer.Tests
             TestUtils.Eventually(() =>
             {
                 model = Assert.IsType<ViewCrowdfundViewModel>(Assert
-                .IsType<ViewResult>(publicApps.ViewCrowdfund(app.Id, string.Empty).Result).Model);
+                .IsType<ViewResult>(publicApps.ViewCrowdfund(app.Id).Result).Model);
                 Assert.Equal(0.7m, model.Info.CurrentPendingAmount);
             });
         }

BTCPayServer.Tests/Extensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -122,6 +123,13 @@ retry:
             driver.ExecuteJavaScript($"document.getElementById('{element}').{funcName}()");
         }
 
+        public static void WaitWalletTransactionsLoaded(this IWebDriver driver)
+        {
+            var wait = new WebDriverWait(driver, SeleniumTester.ImplicitWait);
+            wait.UntilJsIsReady();
+            wait.Until(d => d.WaitForElement(By.CssSelector("#WalletTransactions[data-loaded='true']")));
+        }
+
         public static IWebElement WaitForElement(this IWebDriver driver, By selector)
         {
             var wait = new WebDriverWait(driver, SeleniumTester.ImplicitWait);
@@ -189,6 +197,7 @@ retry:
             driver.FindElement(selector).Click();
         }
 
+        [DebuggerHidden]
         public static bool ElementDoesNotExist(this IWebDriver driver, By selector)
         {
             Assert.Throws<NoSuchElementException>(() =>
@@ -199,11 +208,15 @@ retry:
             return true;
         }
 
-        public static void SetCheckbox(this IWebDriver driver, By selector, bool value)
+        public static bool SetCheckbox(this IWebDriver driver, By selector, bool value)
         {
             var element = driver.FindElement(selector);
             if (value != element.Selected)
+            {
                 driver.WaitForAndClick(selector);
+                return true;
+            }
+            return false;
         }
     }
 }

BTCPayServer.Tests/FastTests.cs

@@ -26,6 +26,7 @@ using BTCPayServer.Services;
 using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Labels;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
 using BTCPayServer.Validation;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
@@ -51,7 +52,6 @@ namespace BTCPayServer.Tests
     {
         public FastTests(ITestOutputHelper helper) : base(helper)
         {
-
         }
         class DockerImage
         {
@@ -135,6 +135,33 @@ namespace BTCPayServer.Tests
             }
         }
 
+
+        [Fact]
+        public void CanParseDecimals()
+        {
+            CanParseDecimalsCore("{\"qty\": 1}", 1.0m);
+            CanParseDecimalsCore("{\"qty\": \"1\"}", 1.0m);
+            CanParseDecimalsCore("{\"qty\": 1.0}", 1.0m);
+            CanParseDecimalsCore("{\"qty\": \"1.0\"}", 1.0m);
+            CanParseDecimalsCore("{\"qty\": 6.1e-7}", 6.1e-7m);
+            CanParseDecimalsCore("{\"qty\": \"6.1e-7\"}", 6.1e-7m);
+
+            var data = JsonConvert.DeserializeObject<TradeRequestData>("{\"qty\": \"6.1e-7\", \"fromAsset\":\"Test\"}");
+            Assert.Equal(6.1e-7m, data.Qty.Value);
+            Assert.Equal("Test", data.FromAsset);
+            data = JsonConvert.DeserializeObject<TradeRequestData>("{\"fromAsset\":\"Test\", \"qty\": \"6.1e-7\"}");
+            Assert.Equal(6.1e-7m, data.Qty.Value);
+            Assert.Equal("Test", data.FromAsset);
+        }
+
+        private void CanParseDecimalsCore(string str, decimal expected)
+        {
+            var d = JsonConvert.DeserializeObject<LedgerEntryData>(str);
+            Assert.Equal(expected, d.Qty);
+            var d2 = JsonConvert.DeserializeObject<TradeRequestData>(str);
+            Assert.Equal(new TradeQuantity(expected, TradeQuantity.ValueType.Exact), d2.Qty);
+        }
+
         [Fact]
         public void CanMergeReceiptOptions()
         {
@@ -319,165 +346,213 @@ namespace BTCPayServer.Tests
             Assert.True(Torrc.TryParse(input, out torrc));
             Assert.Equal(expected, torrc.ToString());
         }
+        [Fact]
+        public void CanCalculateDust()
+        {
+            var entity = new InvoiceEntity() { Currency = "USD" };
+            entity.Networks = new BTCPayNetworkProvider(ChainName.Regtest);
+#pragma warning disable CS0618
+            entity.Payments = new System.Collections.Generic.List<PaymentEntity>();
+            entity.SetPaymentMethod(new PaymentMethod()
+            {
+                Currency = "BTC",
+                Rate = 34_000m
+            });
+            entity.Price = 4000;
+            entity.UpdateTotals();
+            var accounting = entity.GetPaymentMethods().First().Calculate();
+            // Exact price should be 0.117647059..., but the payment method round up to one sat
+            Assert.Equal(0.11764706m, accounting.Due);
+            entity.Payments.Add(new PaymentEntity()
+            {
+                Currency = "BTC",
+                Output = new TxOut(Money.Coins(0.11764706m), new Key()),
+                Accounted = true
+            });
+            entity.UpdateTotals();
+            Assert.Equal(0.0m, entity.NetDue);
+            // The dust's value is below 1 sat
+            Assert.True(entity.Dust > 0.0m);
+            Assert.True(Money.Satoshis(1.0m).ToDecimal(MoneyUnit.BTC) * entity.Rates["BTC"] > entity.Dust);
+            Assert.True(!entity.IsOverPaid);
+            Assert.True(!entity.IsUnderPaid);
+
+            // Now, imagine there is litecoin. It might seem from its
+            // perspecitve that there has been a slight over payment.
+            // However, Calculate() should just cap it to 0.0m
+            entity.SetPaymentMethod(new PaymentMethod()
+            {
+                Currency = "LTC",
+                Rate = 3400m
+            });
+            entity.UpdateTotals();
+            var method = entity.GetPaymentMethods().First(p => p.Currency == "LTC");
+            accounting = method.Calculate();
+            Assert.Equal(0.0m, accounting.DueUncapped);
+
+#pragma warning restore CS0618
+        }
 #if ALTCOINS
         [Fact]
         public void CanCalculateCryptoDue()
         {
             var networkProvider = new BTCPayNetworkProvider(ChainName.Regtest);
-            var paymentMethodHandlerDictionary = new PaymentMethodHandlerDictionary(new IPaymentMethodHandler[]
-            {
-                new BitcoinLikePaymentHandler(null, networkProvider, null, null, null),
-                new LightningLikePaymentHandler(null, null, networkProvider, null, null, null),
-            });
-            var entity = new InvoiceEntity();
+            var entity = new InvoiceEntity() { Currency = "USD" };
             entity.Networks = networkProvider;
 #pragma warning disable CS0618
             entity.Payments = new System.Collections.Generic.List<PaymentEntity>();
             entity.SetPaymentMethod(new PaymentMethod()
             {
-                CryptoCode = "BTC",
+                Currency = "BTC",
                 Rate = 5000,
                 NextNetworkFee = Money.Coins(0.1m)
             });
             entity.Price = 5000;
+            entity.UpdateTotals();
 
             var paymentMethod = entity.GetPaymentMethods().TryGet("BTC", PaymentTypes.BTCLike);
             var accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(1.1m), accounting.Due);
-            Assert.Equal(Money.Coins(1.1m), accounting.TotalDue);
+            Assert.Equal(1.0m, accounting.ToSmallestUnit(Money.Satoshis(1.0m).ToDecimal(MoneyUnit.BTC)));
+            Assert.Equal(1.1m, accounting.Due);
+            Assert.Equal(1.1m, accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity()
             {
+                Currency = "BTC",
                 Output = new TxOut(Money.Coins(0.5m), new Key()),
+                Rate = 5000,
                 Accounted = true,
                 NetworkFee = 0.1m
             });
-
+            entity.UpdateTotals();
             accounting = paymentMethod.Calculate();
             //Since we need to spend one more txout, it should be 1.1 - 0,5 + 0.1
-            Assert.Equal(Money.Coins(0.7m), accounting.Due);
-            Assert.Equal(Money.Coins(1.2m), accounting.TotalDue);
+            Assert.Equal(0.7m, accounting.Due);
+            Assert.Equal(1.2m, accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity()
             {
+                Currency = "BTC",
                 Output = new TxOut(Money.Coins(0.2m), new Key()),
                 Accounted = true,
                 NetworkFee = 0.1m
             });
-
+            entity.UpdateTotals();
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(0.6m), accounting.Due);
-            Assert.Equal(Money.Coins(1.3m), accounting.TotalDue);
+            Assert.Equal(0.6m, accounting.Due);
+            Assert.Equal(1.3m, accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity()
             {
+                Currency = "BTC",
                 Output = new TxOut(Money.Coins(0.6m), new Key()),
                 Accounted = true,
                 NetworkFee = 0.1m
             });
-
+            entity.UpdateTotals();
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Zero, accounting.Due);
-            Assert.Equal(Money.Coins(1.3m), accounting.TotalDue);
+            Assert.Equal(0.0m, accounting.Due);
+            Assert.Equal(1.3m, accounting.TotalDue);
 
             entity.Payments.Add(
-                new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()), Accounted = true });
-
+                new PaymentEntity() { Currency = "BTC", Output = new TxOut(Money.Coins(0.2m), new Key()), Accounted = true });
+            entity.UpdateTotals();
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Zero, accounting.Due);
-            Assert.Equal(Money.Coins(1.3m), accounting.TotalDue);
+            Assert.Equal(0.0m, accounting.Due);
+            Assert.Equal(1.3m, accounting.TotalDue);
 
             entity = new InvoiceEntity();
             entity.Networks = networkProvider;
             entity.Price = 5000;
             PaymentMethodDictionary paymentMethods = new PaymentMethodDictionary();
             paymentMethods.Add(
-                new PaymentMethod() { CryptoCode = "BTC", Rate = 1000, NextNetworkFee = Money.Coins(0.1m) });
+                new PaymentMethod() { Currency = "BTC", Rate = 1000, NextNetworkFee = Money.Coins(0.1m) });
             paymentMethods.Add(
-                new PaymentMethod() { CryptoCode = "LTC", Rate = 500, NextNetworkFee = Money.Coins(0.01m) });
+                new PaymentMethod() { Currency = "LTC", Rate = 500, NextNetworkFee = Money.Coins(0.01m) });
             entity.SetPaymentMethods(paymentMethods);
             entity.Payments = new List<PaymentEntity>();
+            entity.UpdateTotals();
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(5.1m), accounting.Due);
+            Assert.Equal(5.1m, accounting.Due);
 
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
 
-            Assert.Equal(Money.Coins(10.01m), accounting.TotalDue);
+            Assert.Equal(10.01m, accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity()
             {
-                CryptoCode = "BTC",
+                Currency = "BTC",
                 Output = new TxOut(Money.Coins(1.0m), new Key()),
                 Accounted = true,
                 NetworkFee = 0.1m
             });
-
+            entity.UpdateTotals();
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(4.2m), accounting.Due);
-            Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
-            Assert.Equal(Money.Coins(1.0m), accounting.Paid);
-            Assert.Equal(Money.Coins(5.2m), accounting.TotalDue);
+            Assert.Equal(4.2m, accounting.Due);
+            Assert.Equal(1.0m, accounting.CryptoPaid);
+            Assert.Equal(1.0m, accounting.Paid);
+            Assert.Equal(5.2m, accounting.TotalDue);
             Assert.Equal(2, accounting.TxRequired);
 
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(10.01m + 0.1m * 2 - 2.0m /* 8.21m */), accounting.Due);
-            Assert.Equal(Money.Coins(0.0m), accounting.CryptoPaid);
-            Assert.Equal(Money.Coins(2.0m), accounting.Paid);
-            Assert.Equal(Money.Coins(10.01m + 0.1m * 2), accounting.TotalDue);
+            Assert.Equal(10.01m + 0.1m * 2 - 2.0m /* 8.21m */, accounting.Due);
+            Assert.Equal(0.0m, accounting.CryptoPaid);
+            Assert.Equal(2.0m, accounting.Paid);
+            Assert.Equal(10.01m + 0.1m * 2, accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity()
             {
-                CryptoCode = "LTC",
+                Currency = "LTC",
                 Output = new TxOut(Money.Coins(1.0m), new Key()),
                 Accounted = true,
                 NetworkFee = 0.01m
             });
-
+            entity.UpdateTotals();
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(4.2m - 0.5m + 0.01m / 2), accounting.Due);
-            Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
-            Assert.Equal(Money.Coins(1.5m), accounting.Paid);
-            Assert.Equal(Money.Coins(5.2m + 0.01m / 2), accounting.TotalDue); // The fee for LTC added
+            Assert.Equal(4.2m - 0.5m + 0.01m / 2, accounting.Due);
+            Assert.Equal(1.0m, accounting.CryptoPaid);
+            Assert.Equal(1.5m, accounting.Paid);
+            Assert.Equal(5.2m + 0.01m / 2, accounting.TotalDue); // The fee for LTC added
             Assert.Equal(2, accounting.TxRequired);
 
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(8.21m - 1.0m + 0.01m), accounting.Due);
-            Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
-            Assert.Equal(Money.Coins(3.0m), accounting.Paid);
-            Assert.Equal(Money.Coins(10.01m + 0.1m * 2 + 0.01m), accounting.TotalDue);
+            Assert.Equal(8.21m - 1.0m + 0.01m, accounting.Due);
+            Assert.Equal(1.0m, accounting.CryptoPaid);
+            Assert.Equal(3.0m, accounting.Paid);
+            Assert.Equal(10.01m + 0.1m * 2 + 0.01m, accounting.TotalDue);
             Assert.Equal(2, accounting.TxRequired);
 
-            var remaining = Money.Coins(4.2m - 0.5m + 0.01m / 2);
+            var remaining = Money.Coins(4.2m - 0.5m + 0.01m / 2.0m).ToDecimal(MoneyUnit.BTC);
             entity.Payments.Add(new PaymentEntity()
             {
-                CryptoCode = "BTC",
-                Output = new TxOut(remaining, new Key()),
+                Currency = "BTC",
+                Output = new TxOut(Money.Coins(remaining), new Key()),
                 Accounted = true,
                 NetworkFee = 0.1m
             });
-
+            entity.UpdateTotals();
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Zero, accounting.Due);
-            Assert.Equal(Money.Coins(1.0m) + remaining, accounting.CryptoPaid);
-            Assert.Equal(Money.Coins(1.5m) + remaining, accounting.Paid);
-            Assert.Equal(Money.Coins(5.2m + 0.01m / 2), accounting.TotalDue);
+            Assert.Equal(0.0m, accounting.Due);
+            Assert.Equal(1.0m + remaining, accounting.CryptoPaid);
+            Assert.Equal(1.5m + remaining, accounting.Paid);
+            Assert.Equal(5.2m + 0.01m / 2, accounting.TotalDue);
             Assert.Equal(accounting.Paid, accounting.TotalDue);
             Assert.Equal(2, accounting.TxRequired);
 
             paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Zero, accounting.Due);
-            Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
-            Assert.Equal(Money.Coins(3.0m) + remaining * 2, accounting.Paid);
+            Assert.Equal(0.0m, accounting.Due);
+            Assert.Equal(1.0m, accounting.CryptoPaid);
+            Assert.Equal(3.0m + remaining * 2, accounting.Paid);
             // Paying 2 BTC fee, LTC fee removed because fully paid
-            Assert.Equal(Money.Coins(10.01m + 0.1m * 2 + 0.1m * 2 /* + 0.01m no need to pay this fee anymore */),
+            Assert.Equal(10.01m + 0.1m * 2 + 0.1m * 2 /* + 0.01m no need to pay this fee anymore */,
                 accounting.TotalDue);
             Assert.Equal(1, accounting.TxRequired);
             Assert.Equal(accounting.Paid, accounting.TotalDue);
@@ -512,7 +587,7 @@ namespace BTCPayServer.Tests
             var networkProvider = new BTCPayNetworkProvider(ChainName.Regtest);
             var paymentMethodHandlerDictionary = new PaymentMethodHandlerDictionary(new IPaymentMethodHandler[]
             {
-                new BitcoinLikePaymentHandler(null, networkProvider, null, null, null),
+                new BitcoinLikePaymentHandler(null, networkProvider, null, null, null, null),
                 new LightningLikePaymentHandler(null, null, networkProvider, null, null, null),
             });
             var entity = new InvoiceEntity();
@@ -521,27 +596,29 @@ namespace BTCPayServer.Tests
             entity.Payments = new List<PaymentEntity>();
             entity.SetPaymentMethod(new PaymentMethod()
             {
-                CryptoCode = "BTC",
+                Currency = "BTC",
                 Rate = 5000,
                 NextNetworkFee = Money.Coins(0.1m)
             });
             entity.Price = 5000;
             entity.PaymentTolerance = 0;
-
+            entity.UpdateTotals();
 
             var paymentMethod = entity.GetPaymentMethods().TryGet("BTC", PaymentTypes.BTCLike);
             var accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(1.1m), accounting.Due);
-            Assert.Equal(Money.Coins(1.1m), accounting.TotalDue);
-            Assert.Equal(Money.Coins(1.1m), accounting.MinimumTotalDue);
+            Assert.Equal(1.1m, accounting.Due);
+            Assert.Equal(1.1m, accounting.TotalDue);
+            Assert.Equal(1.1m, accounting.MinimumTotalDue);
 
             entity.PaymentTolerance = 10;
+            entity.UpdateTotals();
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(0.99m), accounting.MinimumTotalDue);
+            Assert.Equal(0.99m, accounting.MinimumTotalDue);
 
             entity.PaymentTolerance = 100;
+            entity.UpdateTotals();
             accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Satoshis(1), accounting.MinimumTotalDue);
+            Assert.Equal(0.0000_0001m, accounting.MinimumTotalDue);
         }
 
         [Fact]
@@ -582,7 +659,7 @@ namespace BTCPayServer.Tests
         }
 
         [Fact]
-        public void CanDetectImage()
+        public void CanDetectFileType()
         {
             Assert.True(FileTypeDetector.IsPicture(new byte[] { 0x42, 0x4D }, "test.bmp"));
             Assert.False(FileTypeDetector.IsPicture(new byte[] { 0x42, 0x4D }, ".bmp"));
@@ -595,20 +672,30 @@ namespace BTCPayServer.Tests
             Assert.False(FileTypeDetector.IsPicture(new byte[] { 0x3C, 0x73, 0x76, 0x67 }, "test.jpg"));
             Assert.False(FileTypeDetector.IsPicture(new byte[] { 0xFF }, "e.jpg"));
             Assert.False(FileTypeDetector.IsPicture(new byte[] { }, "empty.jpg"));
+
+            Assert.False(FileTypeDetector.IsPicture(new byte[] { 0x49, 0x44, 0x33, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23 }, "music.mp3"));
+            Assert.True(FileTypeDetector.IsAudio(new byte[] { 0x49, 0x44, 0x33, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23 }, "music.mp3"));
+            Assert.True(FileTypeDetector.IsAudio(new byte[] { 0x52, 0x49, 0x46, 0x46, 0x24, 0x9A, 0x08, 0x00, 0x57, 0x41 }, "music.wav"));
+            Assert.True(FileTypeDetector.IsAudio(new byte[] { 0xFF, 0xF1, 0x50, 0x80, 0x1C, 0x3F, 0xFC, 0xDA, 0x00, 0x4C }, "music.aac"));
+            Assert.True(FileTypeDetector.IsAudio(new byte[] { 0x66, 0x4C, 0x61, 0x43, 0x00, 0x00, 0x00, 0x22, 0x04, 0x80 }, "music.flac"));
+            Assert.True(FileTypeDetector.IsAudio(new byte[] { 0x4F, 0x67, 0x67, 0x53, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 }, "music.ogg"));
+            Assert.True(FileTypeDetector.IsAudio(new byte[] { 0x1A, 0x45, 0xDF, 0xA3, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }, "music.weba"));
+            Assert.True(FileTypeDetector.IsAudio(new byte[] { 0xFF, 0xF3, 0xE4, 0x64, 0x00, 0x20, 0xAD, 0xBD, 0x04, 0x00 }, "music.mp3"));
         }
 
         [Fact]
         public void RoundupCurrenciesCorrectly()
         {
+            DisplayFormatter displayFormatter = new(CurrencyNameTable.Instance);
             foreach (var test in new[]
             {
-                (0.0005m, "$0.0005 (USD)", "USD"), (0.001m, "$0.001 (USD)", "USD"), (0.01m, "$0.01 (USD)", "USD"),
-                (0.1m, "$0.10 (USD)", "USD"), (0.1m, "0,10 € (EUR)", "EUR"), (1000m, "¥1,000 (JPY)", "JPY"),
-                (1000.0001m, "₹ 1,000.00 (INR)", "INR"),
-                (0.0m, "$0.00 (USD)", "USD")
+                (0.0005m, "0.0005 USD", "USD"), (0.001m, "0.001 USD", "USD"), (0.01m, "0.01 USD", "USD"),
+                (0.1m, "0.10 USD", "USD"), (0.1m, "0,10 EUR", "EUR"), (1000m, "1,000 JPY", "JPY"),
+                (1000.0001m, "1,000.00 INR", "INR"),
+                (0.0m, "0.00 USD", "USD")
             })
             {
-                var actual = CurrencyNameTable.Instance.DisplayFormatCurrency(test.Item1, test.Item3);
+                var actual = displayFormatter.Currency(test.Item1, test.Item3);
                 actual = actual.Replace("￥", "¥"); // Hack so JPY test pass on linux as well
                 Assert.Equal(test.Item2, actual);
             }
@@ -706,22 +793,69 @@ namespace BTCPayServer.Tests
             Assert.Throws<ParsingException>(() => { parser.ParseOutputDescriptor("wpkh([8b60afd1/49h/0h/0h]xpub661MyMwAFXkMnyoBjyHndD3QwRbcGVBsTGeNZN6QGVHcfz4MPzBUxjSevweNFQx7SqmMHLdSA4FteGsRrEriu4pnVZMZWnruFFAYZATtcDw/0/*)#9x4vkw48"); }); // invalid checksum
         }
 
+        [Fact]
+        public void ParseTradeQuantity()
+        {
+            Assert.Throws<FormatException>(() => TradeQuantity.Parse("1.2345o"));
+            Assert.Throws<FormatException>(() => TradeQuantity.Parse("o"));
+            Assert.Throws<FormatException>(() => TradeQuantity.Parse(""));
+            Assert.Throws<FormatException>(() => TradeQuantity.Parse("1.353%%"));
+            Assert.Throws<FormatException>(() => TradeQuantity.Parse("1.353 %%"));
+            Assert.Throws<FormatException>(() => TradeQuantity.Parse("-1.353%"));
+            Assert.Throws<FormatException>(() => TradeQuantity.Parse("-1.353"));
+
+            var qty = TradeQuantity.Parse("1.3%");
+            Assert.Equal(1.3m, qty.Value);
+            Assert.Equal(TradeQuantity.ValueType.Percent, qty.Type);
+            var qty2 = TradeQuantity.Parse("1.3");
+            Assert.Equal(1.3m, qty2.Value);
+            Assert.Equal(TradeQuantity.ValueType.Exact, qty2.Type);
+            Assert.NotEqual(qty, qty2);
+            Assert.Equal(qty, TradeQuantity.Parse("1.3%"));
+            Assert.Equal(qty2, TradeQuantity.Parse("1.3"));
+            Assert.Equal(TradeQuantity.Parse(qty.ToString()), TradeQuantity.Parse("1.3%"));
+            Assert.Equal(TradeQuantity.Parse(qty2.ToString()), TradeQuantity.Parse("1.3"));
+            Assert.Equal(TradeQuantity.Parse(qty2.ToString()), TradeQuantity.Parse(" 1.3 "));
+        }
+
         [Fact]
         public void ParseDerivationSchemeSettings()
         {
+            var testnet = new BTCPayNetworkProvider(ChainName.Testnet).GetNetwork<BTCPayNetwork>("BTC");
             var mainnet = new BTCPayNetworkProvider(ChainName.Mainnet).GetNetwork<BTCPayNetwork>("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();
 
+            // xpub
+            var tpub = "tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS";
+            Assert.True(DerivationSchemeSettings.TryParseFromWalletFile(tpub, testnet, out var settings, out var error));
+            Assert.Null(error);
+            Assert.True(settings.AccountDerivation is DirectDerivationStrategy { Segwit: false });
+            Assert.Equal($"{tpub}-[legacy]", ((DirectDerivationStrategy)settings.AccountDerivation).ToString());
+
+            // xpub with fingerprint and account
+            tpub = "tpubDCXK98mNrPWuoWweaoUkqwxQF5NMWpQLy7n7XJgDCpwYfoZRXGafPaVM7mYqD7UKhsbMxkN864JY2PniMkt1Uk4dNuAMnWFVqdquyvZNyca";
+            var vpub = "vpub5YVA1ZbrqkUVq8NZTtvRDrS2a1yoeBvHbG9NbxqJ6uRtpKGFwjQT11WEqKYsgoDF6gpqrDf8ddmPZe4yXWCjzqF8ad2Cw9xHiE8DSi3X3ik";
+            var fingerprint = "e5746fd9";
+            var account = "84'/1'/0'";
+            var str = $"[{fingerprint}/{account}]{vpub}";
+            Assert.True(DerivationSchemeSettings.TryParseFromWalletFile(str, testnet, out settings, out error));
+            Assert.Null(error);
+            Assert.True(settings.AccountDerivation is DirectDerivationStrategy { Segwit: true });
+            Assert.Equal(vpub, settings.AccountOriginal);
+            Assert.Equal(tpub, ((DirectDerivationStrategy)settings.AccountDerivation).ToString());
+            Assert.Equal(HDFingerprint.TryParse(fingerprint, out var hd) ? hd : default, settings.AccountKeySettings[0].RootFingerprint);
+            Assert.Equal(account, settings.AccountKeySettings[0].AccountKeyPath.ToString());
+
             // ColdCard
             Assert.True(DerivationSchemeSettings.TryParseFromWalletFile(
                 "{\"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, out var error));
+                mainnet, out settings, out error));
             Assert.Null(error);
             Assert.Equal(root.GetPublicKey().GetHDFingerPrint(), settings.AccountKeySettings[0].RootFingerprint);
             Assert.Equal(settings.AccountKeySettings[0].RootFingerprint,
-                HDFingerprint.TryParse("8bafd160", out var hd) ? hd : default);
+                HDFingerprint.TryParse("8bafd160", out hd) ? hd : default);
             Assert.Equal("Coldcard Import 0x60d1af8b", settings.Label);
             Assert.Equal("49'/0'/0'", settings.AccountKeySettings[0].AccountKeyPath.ToString());
             Assert.Equal(
@@ -729,28 +863,26 @@ namespace BTCPayServer.Tests
                 settings.AccountOriginal);
             Assert.Equal(root.Derive(new KeyPath("m/49'/0'/0'")).Neuter().PubKey.WitHash.ScriptPubKey.Hash.ScriptPubKey,
                 settings.AccountDerivation.GetDerivation().ScriptPubKey);
-            var testnet = new BTCPayNetworkProvider(ChainName.Testnet).GetNetwork<BTCPayNetwork>("BTC");
 
             // Should be legacy
             Assert.True(DerivationSchemeSettings.TryParseFromWalletFile(
                 "{\"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, out error));
-            Assert.True(settings.AccountDerivation is DirectDerivationStrategy s && !s.Segwit);
+            Assert.True(settings.AccountDerivation is DirectDerivationStrategy { Segwit: false });
             Assert.Null(error);
 
             // Should be segwit p2sh
             Assert.True(DerivationSchemeSettings.TryParseFromWalletFile(
                 "{\"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, out error));
-            Assert.True(settings.AccountDerivation is P2SHDerivationStrategy p &&
-                        p.Inner is DirectDerivationStrategy s2 && s2.Segwit);
+            Assert.True(settings.AccountDerivation is P2SHDerivationStrategy { Inner: DirectDerivationStrategy { Segwit: true } });
             Assert.Null(error);
 
             // Should be segwit
             Assert.True(DerivationSchemeSettings.TryParseFromWalletFile(
                 "{\"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, out error));
-            Assert.True(settings.AccountDerivation is DirectDerivationStrategy s3 && s3.Segwit);
+            Assert.True(settings.AccountDerivation is DirectDerivationStrategy { Segwit: true });
             Assert.Null(error);
 
             // Specter
@@ -970,14 +1102,13 @@ namespace BTCPayServer.Tests
         [Fact]
         public void CanParseFilter()
         {
+            var storeId = "6DehZnc9S7qC6TUTNWuzJ1pFsHTHvES6An21r3MjvLey";
             var filter = "storeid:abc, status:abed, blabhbalh ";
             var search = new SearchString(filter);
             Assert.Equal("storeid:abc, status:abed, blabhbalh", search.ToString());
             Assert.Equal("blabhbalh", search.TextSearch);
-            Assert.Single(search.Filters["storeid"]);
-            Assert.Single(search.Filters["status"]);
-            Assert.Equal("abc", search.Filters["storeid"].First());
-            Assert.Equal("abed", search.Filters["status"].First());
+            Assert.Single(search.Filters["storeid"], "abc");
+            Assert.Single(search.Filters["status"], "abed");
 
             filter = "status:abed, status:abed2";
             search = new SearchString(filter);
@@ -992,6 +1123,48 @@ namespace BTCPayServer.Tests
             search = new SearchString(filter);
             Assert.Equal("2019-04-25 01:00 AM", search.Filters["startdate"].First());
             Assert.Equal("hekki", search.TextSearch);
+
+            // modify search
+            filter = $"status:settled,exceptionstatus:paidLate,unusual:true, fulltext searchterm, storeid:{storeId},startdate:2019-04-25 01:00:00";
+            search = new SearchString(filter);
+            Assert.Equal(filter, search.ToString());
+            Assert.Equal("fulltext searchterm", search.TextSearch);
+            Assert.Single(search.Filters["storeid"], storeId);
+            Assert.Single(search.Filters["status"], "settled");
+            Assert.Single(search.Filters["exceptionstatus"], "paidLate");
+            Assert.Single(search.Filters["unusual"], "true");
+
+            // toggle off bool with same value
+            var modified = new SearchString(search.Toggle("unusual", "true"));
+            Assert.Null(modified.GetFilterBool("unusual"));
+
+            // add to array
+            modified = new SearchString(modified.Toggle("status", "processing"));
+            var statusArray = modified.GetFilterArray("status");
+            Assert.Equal(2, statusArray.Length);
+            Assert.Contains("processing", statusArray);
+            Assert.Contains("settled", statusArray);
+
+            // toggle off array with same value
+            modified = new SearchString(modified.Toggle("status", "settled"));
+            statusArray = modified.GetFilterArray("status");
+            Assert.Single(statusArray, "processing");
+
+            // toggle off array with null value
+            modified = new SearchString(modified.Toggle("status", null));
+            Assert.Null(modified.GetFilterArray("status"));
+
+            // toggle off date with null value
+            modified = new SearchString(modified.Toggle("startdate", "-7d"));
+            Assert.Single(modified.GetFilterArray("startdate"), "-7d");
+            modified = new SearchString(modified.Toggle("startdate", null));
+            Assert.Null(modified.GetFilterArray("startdate"));
+
+            // toggle off date with same value
+            modified = new SearchString(modified.Toggle("enddate", "-7d"));
+            Assert.Single(modified.GetFilterArray("enddate"), "-7d");
+            modified = new SearchString(modified.Toggle("enddate", "-7d"));
+            Assert.Null(modified.GetFilterArray("enddate"));
         }
 
         [Fact]
@@ -1031,6 +1204,45 @@ namespace BTCPayServer.Tests
             Assert.Equal("000000161", m.OrderId);
         }
 
+        [Fact]
+        public void CanParseOldPosAppData()
+        {
+            var data = new JObject()
+            {
+                ["price"] = 1.64m
+            }.ToString();
+            Assert.Equal(1.64m, JsonConvert.DeserializeObject<PosAppCartItem>(data).Price);
+
+            data = new JObject()
+            {
+                ["price"] = new JObject()
+                {
+                    ["value"] = 1.65m
+                }
+            }.ToString();
+            Assert.Equal(1.65m, JsonConvert.DeserializeObject<PosAppCartItem>(data).Price);
+            data = new JObject()
+            {
+                ["price"] = new JObject()
+                {
+                    ["value"] = "1.6305"
+                }
+            }.ToString();
+            Assert.Equal(1.6305m, JsonConvert.DeserializeObject<PosAppCartItem>(data).Price);
+
+            data = new JObject()
+            {
+                ["price"] = new JObject()
+                {
+                    ["value"] = null
+                }
+            }.ToString();
+            Assert.Equal(0.0m, JsonConvert.DeserializeObject<PosAppCartItem>(data).Price);
+
+            var o = JObject.Parse(JsonConvert.SerializeObject(new PosAppCartItem() { Price = 1.356m }));
+            Assert.Equal(1.356m, o["price"].Value<decimal>());
+        }
+
         [Fact]
         public void CanParseCurrencyValue()
         {
@@ -1269,6 +1481,24 @@ namespace BTCPayServer.Tests
             Assert.Equal(cache.States[0].Rates[0].Pair, cache2.States[0].Rates[0].Pair);
         }
 
+        [Fact]
+        public void CanParseStoreRoleId()
+        {
+            var id = StoreRoleId.Parse("test::lol");
+            Assert.Equal("test", id.StoreId);
+            Assert.Equal("lol", id.Role);
+            Assert.Equal("test::lol", id.ToString());
+            Assert.Equal("test::lol", id.Id);
+            Assert.False(id.IsServerRole);
+
+            id = StoreRoleId.Parse("lol");
+            Assert.Null(id.StoreId);
+            Assert.Equal("lol", id.Role);
+            Assert.Equal("lol", id.ToString());
+            Assert.Equal("lol", id.Id);
+            Assert.True(id.IsServerRole);
+        }
+
         [Fact]
         public void KitchenSinkTest()
         {
@@ -1466,14 +1696,14 @@ namespace BTCPayServer.Tests
             Assert.Equal(1m / 0.000061m, rule2.BidAsk.Bid);
 
             // testing rounding 
-            rule2 = rules.GetRuleFor(CurrencyPair.Parse("Sats_EUR"));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("SATS_EUR"));
             rule2.ExchangeRates.SetRate("coinbase", CurrencyPair.Parse("BTC_EUR"), new BidAsk(1.23m, 2.34m));
             Assert.True(rule2.Reevaluate());
             Assert.Equal("0.00000001 * (1.23, 2.34)", rule2.ToString(true));
             Assert.Equal(0.0000000234m, rule2.BidAsk.Ask);
             Assert.Equal(0.0000000123m, rule2.BidAsk.Bid);
 
-            rule2 = rules.GetRuleFor(CurrencyPair.Parse("EUR_Sats"));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("EUR_SATS"));
             rule2.ExchangeRates.SetRate("coinbase", CurrencyPair.Parse("BTC_EUR"), new BidAsk(1.23m, 2.34m));
             Assert.True(rule2.Reevaluate());
             Assert.Equal("1 / (0.00000001 * (1.23, 2.34))", rule2.ToString(true));
@@ -1713,11 +1943,6 @@ namespace BTCPayServer.Tests
 #pragma warning disable CS0618
             var dummy = new Key().PubKey.GetAddress(ScriptPubKeyType.Legacy, Network.RegTest).ToString();
             var networkProvider = new BTCPayNetworkProvider(ChainName.Regtest);
-            var paymentMethodHandlerDictionary = new PaymentMethodHandlerDictionary(new IPaymentMethodHandler[]
-            {
-                new BitcoinLikePaymentHandler(null, networkProvider, null, null, null),
-                new LightningLikePaymentHandler(null, null, networkProvider, null, null, null),
-            });
             var networkBTC = networkProvider.GetNetwork("BTC");
             var networkLTC = networkProvider.GetNetwork("LTC");
             InvoiceEntity invoiceEntity = new InvoiceEntity();
@@ -1725,14 +1950,14 @@ namespace BTCPayServer.Tests
             invoiceEntity.Payments = new System.Collections.Generic.List<PaymentEntity>();
             invoiceEntity.Price = 100;
             PaymentMethodDictionary paymentMethods = new PaymentMethodDictionary();
-            paymentMethods.Add(new PaymentMethod() { Network = networkBTC, CryptoCode = "BTC", Rate = 10513.44m, }
+            paymentMethods.Add(new PaymentMethod() { Network = networkBTC, Currency = "BTC", Rate = 10513.44m, }
                 .SetPaymentMethodDetails(
                     new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
                     {
                         NextNetworkFee = Money.Coins(0.00000100m),
                         DepositAddress = dummy
                     }));
-            paymentMethods.Add(new PaymentMethod() { Network = networkLTC, CryptoCode = "LTC", Rate = 216.79m }
+            paymentMethods.Add(new PaymentMethod() { Network = networkLTC, Currency = "LTC", Rate = 216.79m }
                 .SetPaymentMethodDetails(
                     new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
                     {
@@ -1748,7 +1973,7 @@ namespace BTCPayServer.Tests
                 new PaymentEntity()
                 {
                     Accounted = true,
-                    CryptoCode = "BTC",
+                    Currency = "BTC",
                     NetworkFee = 0.00000100m,
                     Network = networkProvider.GetNetwork("BTC"),
                 }
@@ -1757,34 +1982,33 @@ namespace BTCPayServer.Tests
                         Network = networkProvider.GetNetwork("BTC"),
                         Output = new TxOut() { Value = Money.Coins(0.00151263m) }
                     }));
+            invoiceEntity.UpdateTotals();
             accounting = btc.Calculate();
             invoiceEntity.Payments.Add(
                 new PaymentEntity()
                 {
                     Accounted = true,
-                    CryptoCode = "BTC",
+                    Currency = "BTC",
                     NetworkFee = 0.00000100m,
                     Network = networkProvider.GetNetwork("BTC")
                 }
                     .SetCryptoPaymentData(new BitcoinLikePaymentData()
                     {
                         Network = networkProvider.GetNetwork("BTC"),
-                        Output = new TxOut() { Value = accounting.Due }
+                        Output = new TxOut() { Value = Money.Coins(accounting.Due) }
                     }));
+            invoiceEntity.UpdateTotals();
             accounting = btc.Calculate();
-            Assert.Equal(Money.Zero, accounting.Due);
-            Assert.Equal(Money.Zero, accounting.DueUncapped);
+            Assert.Equal(0.0m, accounting.Due);
+            Assert.Equal(0.0m, accounting.DueUncapped);
 
             var ltc = invoiceEntity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             accounting = ltc.Calculate();
 
-            Assert.Equal(Money.Zero, accounting.Due);
-            // LTC might have over paid due to BTC paying above what it should (round 1 satoshi up)
-            Assert.True(accounting.DueUncapped < Money.Zero);
-
-            var paymentMethod = InvoiceWatcher.GetNearestClearedPayment(paymentMethods, out var accounting2);
-            Assert.Equal(btc.CryptoCode, paymentMethod.CryptoCode);
-#pragma warning restore CS0618
+            Assert.Equal(0.0m, accounting.Due);
+            // LTC might should be over paid due to BTC paying above what it should (round 1 satoshi up), but we handle this case
+            // and set DueUncapped to zero.
+            Assert.Equal(0.0m, accounting.DueUncapped);
         }
 
         [Fact]

BTCPayServer.Tests/FormTests.cs

@@ -1,6 +1,4 @@
-using System;
 using System.Collections.Generic;
-using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using BTCPayServer.Abstractions.Form;
 using BTCPayServer.Forms;
@@ -42,9 +40,10 @@ public class FormTests : UnitTestBase
                 }
             }
         };
-        var service = new FormDataService(null, null);
+        var providers = new FormComponentProviders(new List<IFormComponentProvider>());
+        var service = new FormDataService(null, providers);
         Assert.False(service.IsFormSchemaValid(form.ToString(), out _, out _));
-        form = new Form()
+        form = new Form
         {
             Fields = new List<Field>
             {
@@ -117,7 +116,7 @@ public class FormTests : UnitTestBase
                     break;
             }
         }
-        
+
         form = new Form()
         {
             Fields = new List<Field>
@@ -144,7 +143,7 @@ public class FormTests : UnitTestBase
             {"invoice_item3", new StringValues("updated")},
             {"invoice_test", new StringValues("updated")}
         }));
-        
+
         foreach (var f in form.GetAllFields())
         {
             var field = f.Field;
@@ -161,12 +160,12 @@ public class FormTests : UnitTestBase
             }
         }
 
-        var obj = form.GetValues();
+        var obj = service.GetValues(form);
         Assert.Equal("original", obj["invoice"]["test"].Value<string>());
         Assert.Equal("updated", obj["invoice_item3"].Value<string>());
         Clear(form);
         form.SetValues(obj);
-        obj = form.GetValues();
+        obj = service.GetValues(form);
         Assert.Equal("original", obj["invoice"]["test"].Value<string>());
         Assert.Equal("updated", obj["invoice_item3"].Value<string>());
 
@@ -184,10 +183,10 @@ public class FormTests : UnitTestBase
             }
         };
         form.SetValues(obj);
-        obj = form.GetValues();
+        obj = service.GetValues(form);
         Assert.Null(obj["test"].Value<string>());
-        form.SetValues(new JObject{ ["test"] = "hello" });
-        obj = form.GetValues();
+        form.SetValues(new JObject { ["test"] = "hello" });
+        obj = service.GetValues(form);
         Assert.Equal("hello", obj["test"].Value<string>());
     }
 

BTCPayServer.Tests/MockCustodian/MockCustodian.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Abstractions.Custodians;
@@ -24,6 +25,9 @@ public class MockCustodian : ICustodian, ICanDeposit, ICanTrade, ICanWithdraw
     public const string WithdrawalAsset = "BTC";
     public const string WithdrawalId = "WITHDRAWAL-ID-001";
     public static readonly decimal WithdrawalAmount = new decimal(0.5);
+    public static readonly string WithdrawalAmountPercentage = "12.5%";
+    public static readonly decimal WithdrawalMinAmount = new decimal(0.001);
+    public static readonly decimal WithdrawalMaxAmount = new decimal(0.6);
     public static readonly decimal WithdrawalFee = new decimal(0.0005);
     public const string WithdrawalTransactionId = "yyy";
     public const string WithdrawalTargetAddress = "bc1qyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy";
@@ -52,7 +56,7 @@ public class MockCustodian : ICustodian, ICanDeposit, ICanTrade, ICanWithdraw
         return Task.FromResult(r);
     }
 
-    public Task<Form> GetConfigForm(JObject config, string locale, CancellationToken cancellationToken = default)
+    public Task<Form> GetConfigForm(JObject config, CancellationToken cancellationToken = default)
     {
         return null;
     }
@@ -136,13 +140,37 @@ public class MockCustodian : ICustodian, ICanDeposit, ICanTrade, ICanWithdraw
         return r;
     }
 
-    public Task<WithdrawResult> WithdrawAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken)
+    private SimulateWithdrawalResult CreateWithdrawSimulationResult()
+    {
+        var ledgerEntries = new List<LedgerEntryData>();
+        ledgerEntries.Add(new LedgerEntryData(WithdrawalAsset, WithdrawalAmount - WithdrawalFee, LedgerEntryData.LedgerEntryType.Withdrawal));
+        ledgerEntries.Add(new LedgerEntryData(WithdrawalAsset, WithdrawalFee, LedgerEntryData.LedgerEntryType.Fee));
+        var r = new SimulateWithdrawalResult(WithdrawalPaymentMethod, WithdrawalAsset, ledgerEntries, WithdrawalMinAmount, WithdrawalMaxAmount);
+        return r;
+    }
+
+    public Task<WithdrawResult> WithdrawToStoreWalletAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken)
+    {
+        if (paymentMethod == WithdrawalPaymentMethod)
+        {
+            if (amount.ToString(CultureInfo.InvariantCulture).Equals("" + WithdrawalAmount, StringComparison.InvariantCulture) || WithdrawalAmountPercentage.Equals(amount))
+            {
+                return Task.FromResult(CreateWithdrawResult());
+            }
+
+            throw new InsufficientFundsException($"{Name} only supports withdrawals of {WithdrawalAmount} or {WithdrawalAmountPercentage}");
+        }
+
+        throw new CannotWithdrawException(this, paymentMethod, $"Only {WithdrawalPaymentMethod} can be withdrawn from {Name}");
+    }
+
+    public Task<SimulateWithdrawalResult> SimulateWithdrawalAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken)
     {
         if (paymentMethod == WithdrawalPaymentMethod)
         {
             if (amount == WithdrawalAmount)
             {
-                return Task.FromResult(CreateWithdrawResult());
+                return Task.FromResult(CreateWithdrawSimulationResult());
             }
 
             throw new InsufficientFundsException($"{Name} only supports withdrawals of {WithdrawalAmount}");

BTCPayServer.Tests/POSTests.cs

@@ -1,11 +1,12 @@
 using System.Threading.Tasks;
 using BTCPayServer.Controllers;
 using BTCPayServer.Data;
+using BTCPayServer.Hosting;
 using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Plugins.PointOfSale;
 using BTCPayServer.Plugins.PointOfSale.Controllers;
 using BTCPayServer.Plugins.PointOfSale.Models;
 using BTCPayServer.Services.Apps;
-using BTCPayServer.Tests.Logging;
 using Microsoft.AspNetCore.Mvc;
 using Xunit;
 using Xunit.Abstractions;
@@ -20,6 +21,74 @@ namespace BTCPayServer.Tests
         {
         }
 
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void CanParseOldYmlCorrectly()
+        {
+              var testOriginalDefaultYmlTemplate = @"
+green tea:
+  price: 1
+  title: Green Tea
+  description:  Lovely, fresh and tender, Meng Ding Gan Lu ('sweet dew') is grown in the lush Meng Ding Mountains of the southwestern province of Sichuan where it has been cultivated for over a thousand years.
+  image: ~/img/pos-sample/green-tea.jpg
+
+black tea:
+  price: 1
+  title: Black Tea
+  description: Tian Jian Tian Jian means 'heavenly tippy tea' in Chinese, and it describes the finest grade of dark tea. Our Tian Jian dark tea is from Hunan province which is famous for making some of the best dark teas available.
+  image: ~/img/pos-sample/black-tea.jpg
+
+rooibos:
+  price: 1.2
+  title: Rooibos
+  description: Rooibos is a dramatic red tea made from a South African herb that contains polyphenols and flavonoids. Often called 'African redbush tea', Rooibos herbal tea delights the senses and delivers potential health benefits with each caffeine-free sip.
+  image: ~/img/pos-sample/rooibos.jpg
+
+pu erh:
+  price: 2
+  title: Pu Erh
+  description: This loose pur-erh tea is produced in Yunnan Province, China. The process in a relatively high humidity environment has mellowed the elemental character of the tea when compared to young Pu-erh.
+  image: ~/img/pos-sample/pu-erh.jpg
+
+herbal tea:
+  price: 1.8
+  title: Herbal Tea
+  description: Chamomile tea is made from the flower heads of the chamomile plant. The medicinal use of chamomile dates back to the ancient Egyptians, Romans and Greeks. Pay us what you want!
+  image: ~/img/pos-sample/herbal-tea.jpg
+  custom: true
+
+fruit tea:
+  price: 1.5
+  title: Fruit Tea
+  description: The Tibetan Himalayas, the land is majestic and beautiful—a spiritual place where, despite the perilous environment, many journey seeking enlightenment. Pay us what you want!
+  image: ~/img/pos-sample/fruit-tea.jpg
+  inventory: 5
+  custom: true
+";
+        var parsedDefault =     MigrationStartupTask.ParsePOSYML(testOriginalDefaultYmlTemplate);
+        Assert.Equal(6, parsedDefault.Length);
+        Assert.Equal( "Green Tea" ,parsedDefault[0].Title);
+        Assert.Equal( "green tea" ,parsedDefault[0].Id);
+        Assert.Equal( "Lovely, fresh and tender, Meng Ding Gan Lu ('sweet dew') is grown in the lush Meng Ding Mountains of the southwestern province of Sichuan where it has been cultivated for over a thousand years." ,parsedDefault[0].Description);
+        Assert.Null( parsedDefault[0].BuyButtonText);
+        Assert.Equal( "~/img/pos-sample/green-tea.jpg" ,parsedDefault[0].Image);
+        Assert.Equal( 1 ,parsedDefault[0].Price);
+        Assert.Equal( ViewPointOfSaleViewModel.ItemPriceType.Fixed ,parsedDefault[0].PriceType);
+        Assert.Null( parsedDefault[0].AdditionalData);
+        Assert.Null( parsedDefault[0].PaymentMethods);
+        
+        
+        Assert.Equal( "Herbal Tea" ,parsedDefault[4].Title);
+        Assert.Equal( "herbal tea" ,parsedDefault[4].Id);
+        Assert.Equal( "Chamomile tea is made from the flower heads of the chamomile plant. The medicinal use of chamomile dates back to the ancient Egyptians, Romans and Greeks. Pay us what you want!" ,parsedDefault[4].Description);
+        Assert.Null( parsedDefault[4].BuyButtonText);
+        Assert.Equal( "~/img/pos-sample/herbal-tea.jpg" ,parsedDefault[4].Image);
+        Assert.Equal( 1.8m ,parsedDefault[4].Price);
+        Assert.Equal( ViewPointOfSaleViewModel.ItemPriceType.Minimum ,parsedDefault[4].PriceType);
+        Assert.Null( parsedDefault[4].AdditionalData);
+        Assert.Null( parsedDefault[4].PaymentMethods);
+        }
+        
         [Fact(Timeout = LongRunningTestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanUsePoSApp1()
@@ -32,10 +101,11 @@ namespace BTCPayServer.Tests
             var apps = user.GetController<UIAppsController>();
             var pos = user.GetController<UIPointOfSaleController>();
             var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp(user.StoreId)).Model);
-            var appType = AppType.PointOfSale.ToString();
+            var appType = PointOfSaleAppType.AppType;
             vm.AppName = "test";
             vm.SelectedAppType = appType;
-            Assert.IsType<RedirectToActionResult>(apps.CreateApp(user.StoreId, vm).Result);
+            var redirect = Assert.IsType<RedirectResult>(apps.CreateApp(user.StoreId, vm).Result);
+            Assert.EndsWith("/settings/pos", redirect.Url);
             var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps(user.StoreId).Result).Model);
             var app = appList.Apps[0];
             var appData = new AppData { Id = app.Id, StoreDataId = app.StoreId, Name = app.AppName, AppType = appType };
@@ -53,6 +123,7 @@ donation:
   price: 1.02
   custom: true
 ";
+            vmpos.Template = AppService.SerializeTemplate(MigrationStartupTask.ParsePOSYML(vmpos.Template));
             Assert.IsType<RedirectToActionResult>(pos.UpdatePointOfSale(app.Id, vmpos).Result);
             await pos.UpdatePointOfSale(app.Id).AssertViewModelAsync<UpdatePointOfSaleViewModel>();
             var publicApps = user.GetController<UIPointOfSaleController>();
@@ -64,10 +135,10 @@ donation:
             Assert.Equal("donation", vmview.Items[1].Title);
             // orange is available
             Assert.IsType<RedirectToActionResult>(publicApps
-                .ViewPointOfSale(app.Id, PosViewType.Cart, 0, null, null, null, null, "orange").Result);
+                .ViewPointOfSale(app.Id, PosViewType.Cart, 0, choiceKey: "orange").Result);
             // apple is not found
             Assert.IsType<NotFoundResult>(publicApps
-                .ViewPointOfSale(app.Id, PosViewType.Cart, 0, null, null, null, null, "apple").Result);
+                .ViewPointOfSale(app.Id, PosViewType.Cart, 0, choiceKey: "apple").Result);
         }
     }
 }

BTCPayServer.Tests/PayJoinTests.cs

@@ -221,7 +221,7 @@ namespace BTCPayServer.Tests
                     var receiverCoin = await receiverUser.ReceiveUTXO(Money.Satoshis(810), network);
 
                     string errorCode = receiverAddressType == senderAddressType ? null : "unavailable|any UTXO available";
-                    var invoice = receiverUser.BitPay.CreateInvoice(new Invoice() { Price = 50000, Currency = "sats", FullNotifications = true });
+                    var invoice = receiverUser.BitPay.CreateInvoice(new Invoice() { Price = 50000, Currency = "SATS", FullNotifications = true });
                     if (unsupportedFormats.Contains(receiverAddressType))
                     {
                         Assert.Null(TestAccount.GetPayjoinBitcoinUrl(invoice, cashCow.Network));
@@ -249,6 +249,7 @@ namespace BTCPayServer.Tests
             await s.StartAsync();
             s.RegisterNewUser(true);
             var receiver = s.CreateNewStore();
+            s.EnableCheckout(CheckoutType.V1);
             var receiverSeed = s.GenerateWallet("BTC", "", true, true, ScriptPubKeyType.Segwit);
             var receiverWalletId = new WalletId(receiver.storeId, "BTC");
 
@@ -303,6 +304,7 @@ namespace BTCPayServer.Tests
             {
                 var cryptoCode = "BTC";
                 var receiver = s.CreateNewStore();
+                s.EnableCheckout(CheckoutType.V1);
                 var receiverSeed = s.GenerateWallet(cryptoCode, "", true, true, format);
                 var receiverWalletId = new WalletId(receiver.storeId, cryptoCode);
 

BTCPayServer.Tests/SeleniumTester.cs

@@ -1,10 +1,12 @@
 using System;
+using System.ComponentModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Abstractions.Extensions;
 using BTCPayServer.Abstractions.Models;
+using BTCPayServer.Client.Models;
 using BTCPayServer.Lightning;
 using BTCPayServer.Lightning.CLightning;
 using BTCPayServer.Views.Manage;
@@ -63,7 +65,6 @@ namespace BTCPayServer.Tests
                 var containerIp = File.ReadAllText("/etc/hosts").Split('\n', StringSplitOptions.RemoveEmptyEntries).Last()
                     .Split('\t', StringSplitOptions.RemoveEmptyEntries)[0].Trim();
                 TestLogs.LogInformation($"Selenium: Container's IP {containerIp}");
-                ServerUri = new Uri(Server.PayTester.ServerUri.AbsoluteUri.Replace($"http://{Server.PayTester.HostName}", $"http://{containerIp}", StringComparison.OrdinalIgnoreCase), UriKind.Absolute);
             }
             else
             {
@@ -75,8 +76,8 @@ namespace BTCPayServer.Tests
                 Driver = new ChromeDriver(cds, options,
                     // A bit less than test timeout
                     TimeSpan.FromSeconds(50));
-                ServerUri = Server.PayTester.ServerUri;
             }
+            ServerUri = Server.PayTester.ServerUri;
             Driver.Manage().Window.Maximize();
 
             TestLogs.LogInformation($"Selenium: Using {Driver.GetType()}");
@@ -86,7 +87,7 @@ namespace BTCPayServer.Tests
             Driver.AssertNoError();
         }
 
-        public void PayInvoice(bool mine = false, decimal? amount= null)
+        public void PayInvoice(bool mine = false, decimal? amount = null)
         {
 
             if (amount is not null)
@@ -94,6 +95,7 @@ namespace BTCPayServer.Tests
                 Driver.FindElement(By.Id("test-payment-amount")).Clear();
                 Driver.FindElement(By.Id("test-payment-amount")).SendKeys(amount.ToString());
             }
+            Driver.WaitUntilAvailable(By.Id("FakePayment"));
             Driver.FindElement(By.Id("FakePayment")).Click();
             if (mine)
             {
@@ -178,7 +180,7 @@ namespace BTCPayServer.Tests
             {
                 Driver.FindElement(By.Id("StoreSelectorToggle")).Click();
             }
-            Driver.WaitForElement(By.Id("StoreSelectorCreate")).Click();
+            GoToUrl("/stores/create");
             var name = "Store" + RandomUtils.GetUInt64();
             TestLogs.LogInformation($"Created store {name}");
             Driver.WaitForElement(By.Id("Name")).SendKeys(name);
@@ -193,16 +195,22 @@ namespace BTCPayServer.Tests
                 StoreId = storeId;
             return (name, storeId);
         }
-
-        public void EnableCheckoutV2(bool bip21 = false)
+        public void EnableCheckout(CheckoutType checkoutType, bool bip21 = false)
         {
             GoToStore(StoreNavPages.CheckoutAppearance);
-            Driver.SetCheckbox(By.Id("UseNewCheckout"), true);
-            Driver.WaitForElement(By.Id("OnChainWithLnInvoiceFallback"));
-            Driver.SetCheckbox(By.Id("OnChainWithLnInvoiceFallback"), bip21);
+            if (checkoutType == CheckoutType.V2)
+            {
+                Driver.SetCheckbox(By.Id("UseClassicCheckout"), false);
+                Driver.WaitForElement(By.Id("OnChainWithLnInvoiceFallback"));
+                Driver.SetCheckbox(By.Id("OnChainWithLnInvoiceFallback"), bip21);
+            }
+            else
+            {
+                Driver.SetCheckbox(By.Id("UseClassicCheckout"), true);
+            }
             Driver.FindElement(By.Id("Save")).SendKeys(Keys.Enter);
             Assert.Contains("Store successfully updated", FindAlertMessage().Text);
-            Assert.True(Driver.FindElement(By.Id("UseNewCheckout")).Selected);
+            Assert.True(Driver.FindElement(By.Id("UseClassicCheckout")).Selected);
         }
 
         public Mnemonic GenerateWallet(string cryptoCode = "BTC", string seed = "", bool? importkeys = null, bool isHotWallet = false, ScriptPubKeyType format = ScriptPubKeyType.Segwit)
@@ -305,8 +313,6 @@ namespace BTCPayServer.Tests
 
             var connectionString = connectionType switch
             {
-                LightningConnectionType.Charge =>
-                    $"type=charge;server={Server.MerchantCharge.Client.Uri.AbsoluteUri};allowinsecure=true",
                 LightningConnectionType.CLightning =>
                     $"type=clightning;server={((CLightningClient)Server.MerchantLightningD).Address.AbsoluteUri}",
                 LightningConnectionType.LndREST =>
@@ -387,6 +393,10 @@ namespace BTCPayServer.Tests
         public void GoToHome()
         {
             Driver.Navigate().GoToUrl(ServerUri);
+            if (Driver.PageSource.Contains("id=\"SkipWizard\""))
+            {
+                Driver.FindElement(By.Id("SkipWizard")).Click();
+            }
         }
 
         public void Logout()