Remove untested and unfinished code

* Do not show remaining amount for topup invoices in expiry message

As [reported by @petzsch](https://chat.btcpayserver.org/btcpayserver/pl/gg1zy8t5h3dq7nme1nom93migo).

* Fix links on result page in Checkout Classic

Closes #4344.

* Better way to exclude Lightning if BIP21 is active and we have both PMs


Unify margins

.circleci/config.yml

@@ -41,9 +41,10 @@ jobs:
       - run:
           command: |
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            GIT_COMMIT=$(git rev-parse HEAD)
             #
-            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f amd64.Dockerfile .
-            sudo docker build --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 -f amd64.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f amd64.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 -f amd64.Dockerfile .
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-amd64
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64
@@ -57,9 +58,10 @@ jobs:
           command: |
             sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            GIT_COMMIT=$(git rev-parse HEAD)
             #
-            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f arm32v7.Dockerfile .
-            sudo docker build --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 -f arm32v7.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f arm32v7.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 -f arm32v7.Dockerfile .
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7
@@ -73,9 +75,10 @@ jobs:
           command: |
             sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            GIT_COMMIT=$(git rev-parse HEAD)
             #
-            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 -f arm64v8.Dockerfile .
-            sudo docker build --build-arg CONFIGURATION_NAME=Altcoins-Release --pull -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8 -f arm64v8.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 -f arm64v8.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --build-arg CONFIGURATION_NAME=Altcoins-Release --pull -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8 -f arm64v8.Dockerfile .
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm64v8
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8

.editorconfig

@@ -12,7 +12,7 @@ indent_style = space
 indent_size = 4
 charset = utf-8
 
-[launchSettings.json]
+[*.json]
 indent_size = 2
 
 # C# files

.gitignore

@@ -288,10 +288,6 @@ __pycache__/
 *.xsd.cs
 /BTCPayServer/Build/dockerfiles
 
-# Bundling JS/CSS
-BTCPayServer/wwwroot/bundles/*
-!BTCPayServer/wwwroot/bundles/.gitignore
-
 .vscode/*
 !.vscode/launch.json
 !.vscode/tasks.json

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -32,9 +32,9 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="HtmlSanitizer" Version="5.0.372" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.7" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.7" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.9" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.9" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.7" />
     <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="6.0.1" />
   </ItemGroup>
   <ItemGroup>

BTCPayServer.Abstractions/Extensions/ViewsRazor.cs

@@ -14,6 +14,12 @@ namespace BTCPayServer.Abstractions.Extensions
         private const string ACTIVE_ID_KEY = "ActiveId";
         private const string ActivePageClass = "active";
 
+        public enum DateDisplayFormat
+        {
+            Localized,
+            Relative
+        }
+
         public static void SetActivePage<T>(this ViewDataDictionary viewData, T activePage, string title = null, string activeId = null)
             where T : IConvertible
         {
@@ -86,26 +92,29 @@ namespace BTCPayServer.Abstractions.Extensions
             return categoryAndPageMatch && idMatch ? ActivePageClass : null;
         }
 
-        public static HtmlString ToBrowserDate(this DateTimeOffset date)
+        public static HtmlString ToBrowserDate(this DateTimeOffset date, DateDisplayFormat format = DateDisplayFormat.Localized)
         {
-            var displayDate = date.ToString("o", CultureInfo.InvariantCulture);
-            return new HtmlString($"<span class='localizeDate'>{displayDate}</span>");
+            var relative = date.ToTimeAgo();
+            var initial = format.ToString().ToLower();
+            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
+            var displayDate = format == DateDisplayFormat.Relative ? relative : date.ToString("g", CultureInfo.InvariantCulture);
+            return new HtmlString($"<time datetime=\"{dateTime}\" data-relative=\"{relative}\" data-initial=\"{initial}\">{displayDate}</time>");
         }
 
-        public static HtmlString ToBrowserDate(this DateTime date)
+        public static HtmlString ToBrowserDate(this DateTime date, DateDisplayFormat format = DateDisplayFormat.Localized)
         {
-            var displayDate = date.ToString("o", CultureInfo.InvariantCulture);
-            return new HtmlString($"<span class='localizeDate'>{displayDate}</span>");
+            var relative = date.ToTimeAgo();
+            var initial = format.ToString().ToLower();
+            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
+            var displayDate = format == DateDisplayFormat.Relative ? relative : date.ToString("g", CultureInfo.InvariantCulture);
+            return new HtmlString($"<time datetime=\"{dateTime}\" data-relative=\"{relative}\" data-initial=\"{initial}\">{displayDate}</time>");
         }
 
-        public static string ToTimeAgo(this DateTimeOffset date)
-        {
-            var diff = DateTimeOffset.UtcNow - date;
-            var formatted = diff.TotalSeconds > 0
-                ? $"{diff.TimeString()} ago"
-                : $"in {diff.Negate().TimeString()}";
-            return formatted;
-        }
+        public static string ToTimeAgo(this DateTimeOffset date) => (DateTimeOffset.UtcNow - date).ToTimeAgo();
+
+        public static string ToTimeAgo(this DateTime date) => (DateTimeOffset.UtcNow - date).ToTimeAgo();
+
+        public static string ToTimeAgo(this TimeSpan diff) => diff.TotalSeconds > 0 ? $"{diff.TimeString()} ago" : $"in {diff.Negate().TimeString()}";
 
         public static string TimeString(this TimeSpan timeSpan)
         {
@@ -117,16 +126,14 @@ namespace BTCPayServer.Abstractions.Extensions
             {
                 return $"{(int)timeSpan.TotalMinutes} minute{Plural((int)timeSpan.TotalMinutes)}";
             }
-            if (timeSpan.Days < 1)
-            {
-                return $"{(int)timeSpan.TotalHours} hour{Plural((int)timeSpan.TotalHours)}";
-            }
-            return $"{(int)timeSpan.TotalDays} day{Plural((int)timeSpan.TotalDays)}";
+            return timeSpan.Days < 1 
+                ? $"{(int)timeSpan.TotalHours} hour{Plural((int)timeSpan.TotalHours)}"
+                : $"{(int)timeSpan.TotalDays} day{Plural((int)timeSpan.TotalDays)}";
         }
 
         private static string Plural(int value)
         {
-            return value > 1 ? "s" : string.Empty;
+            return value == 1 ? string.Empty : "s";
         }
     }
 }

BTCPayServer.Abstractions/Form/Field.cs

@@ -1,35 +1,34 @@
+using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Abstractions.Form;
 
-public abstract class Field
+public class Field
 {
-    // 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).
-    public string Type;
-    
     // The name of the HTML5 node. Should be used as the key for the posted data.
     public string Name;
-    
-    // The translated label of the field.
-    public string Label;
-    
+
+    // 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).
+    public string Type;
+
     // The value field is what is currently in the DB or what the user entered, but possibly not saved yet due to validation errors.
     // If this is the first the user sees the form, then value and original value are the same. Value changes as the user starts interacting with the form.
     public string Value;
 
-    // The original value is the value that is currently saved in the backend. A "reset" button can be used to revert back to this. Should only be set from the constructor.
-    public string OriginalValue;
-
-    // A useful note shown below the field or via a tooltip / info icon. Should be translated for the user.
-    public string HelpText;
-    
     // The field is considered "valid" if there are no validation errors
     public List<string> ValidationErrors = new List<string>();
 
-    public bool Required = false;
-
-    public bool IsValid()
+    public virtual bool IsValid()
     {
-        return ValidationErrors.Count == 0;
+        return ValidationErrors.Count == 0 && Fields.All(field => field.IsValid());
     }
+
+    [JsonExtensionData] public IDictionary<string, JToken> AdditionalData { get; set; }
+    public List<Field> Fields { get; set; } = new();
+    
+   
 }

BTCPayServer.Abstractions/Form/Fieldset.cs

@@ -1,14 +1,12 @@
-using System.Collections.Generic;
-
 namespace BTCPayServer.Abstractions.Form;
 
-public class Fieldset
+public class Fieldset : Field
 {
+    public bool Hidden { get; set; }
+    public string Label { get; set; }
+
     public Fieldset()
     {
-        this.Fields = new List<Field>();
+        Type = "fieldset";
     }
-
-    public string Label { get; set; }
-    public List<Field> Fields { get; set; }
 }

BTCPayServer.Abstractions/Form/Form.cs

@@ -1,60 +1,143 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Http;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Abstractions.Form;
 
 public class Form
 {
-
     // Messages to be shown at the top of the form indicating user feedback like "Saved successfully" or "Please change X because of Y." or a warning, etc...
     public List<AlertMessage> TopMessages { get; set; } = new();
     
     // Groups of fields in the form
-    public List<Fieldset> Fieldsets { get; set; } = new();
+    public List<Field> Fields { get; set; } = new();
     
-
     // Are all the fields valid in the form?
     public bool IsValid()
     {
-        foreach (var fieldset in Fieldsets)
-        {
-            foreach (var field in fieldset.Fields)
-            {
-                if (!field.IsValid())
-                {
-                    return false;
-                }
-            }
-        }
-
-        return true;
+        return Fields.All(field => field.IsValid());
     }
 
     public Field GetFieldByName(string name)
     {
-        foreach (var fieldset in Fieldsets)
+        return GetFieldByName(name, Fields, null);
+    }
+    
+    private static Field GetFieldByName(string name, List<Field> fields, string prefix)
+    {
+        prefix ??= string.Empty;
+        foreach (var field in fields)
         {
-            foreach (var field in fieldset.Fields)
+            var currentPrefix = prefix;
+            if (!string.IsNullOrEmpty(field.Name))
             {
-                if (name.Equals(field.Name))
+                
+                currentPrefix = $"{prefix}{field.Name}";
+                if (currentPrefix.Equals(name, StringComparison.InvariantCultureIgnoreCase))
                 {
                     return field;
                 }
+
+                currentPrefix += "_";
             }
+
+            var subFieldResult = GetFieldByName(name, field.Fields, currentPrefix);
+            if (subFieldResult is not null)
+            {
+                return subFieldResult;
+            }
+            
         }
         return null;
     }
-
     public List<string> GetAllNames()
+    {
+        return GetAllNames(Fields);
+    }
+
+    private static List<string> GetAllNames(List<Field> fields)
     {
         var names = new List<string>();
-        foreach (var fieldset in Fieldsets)
+        
+        foreach (var field in fields)
         {
-            foreach (var field in fieldset.Fields)
+            string prefix = string.Empty;
+            if (!string.IsNullOrEmpty(field.Name))
             {
                 names.Add(field.Name);
+                prefix = $"{field.Name}_";
+            }
+
+            if (field.Fields.Any())
+            {
+                names.AddRange(GetAllNames(field.Fields).Select(s => $"{prefix}{s}" ));
             }
         }
 
         return names;
     }
+
+    public void ApplyValuesFromOtherForm(Form form)
+    {
+        foreach (var fieldset in Fields)
+        {
+            foreach (var field in fieldset.Fields)
+            {
+                field.Value = form
+                    .GetFieldByName(
+                        $"{(string.IsNullOrEmpty(fieldset.Name) ? string.Empty : fieldset.Name + "_")}{field.Name}")
+                    ?.Value;
+            }
+        }
+    }
+    
+    public void ApplyValuesFromForm(IFormCollection form)
+    {
+        var names = GetAllNames();
+        foreach (var name in names)
+        {
+            var field = GetFieldByName(name);
+            if (field is null || !form.TryGetValue(name, out var val))
+            {
+                continue;
+            }
+
+            field.Value = val;
+        }
+    }
+
+    public Dictionary<string, object> GetValues()
+    {
+        return GetValues(Fields);
+    }
+    
+    private static Dictionary<string, object> GetValues(List<Field> fields)
+    {
+        var result = new Dictionary<string, object>();
+        foreach (Field field in fields)
+        {
+            var name = field.Name ?? string.Empty;
+            if (field.Fields.Any())
+            {
+                var values = GetValues(fields);
+                values.Remove(string.Empty, out var keylessValue);
+                
+                result.TryAdd(name, values);
+
+                if (keylessValue is not Dictionary<string, object> dict) continue;
+                foreach (KeyValuePair<string,object> keyValuePair in dict)
+                {
+                    result.TryAdd(keyValuePair.Key, keyValuePair.Value);
+                }
+            }
+            else
+            {
+                result.TryAdd(name, field.Value);
+            }
+        }
+
+        return result;
+    }
 }

BTCPayServer.Abstractions/Form/HtmlInputField.cs

@@ -0,0 +1,27 @@
+namespace BTCPayServer.Abstractions.Form;
+
+public class HtmlInputField : Field
+{
+    // The translated label of the field.
+    public string Label;
+    
+    // The original value is the value that is currently saved in the backend. A "reset" button can be used to revert back to this. Should only be set from the constructor.
+    public string OriginalValue;
+
+    // A useful note shown below the field or via a tooltip / info icon. Should be translated for the user.
+    public string HelpText;
+
+    public bool Required;
+    public HtmlInputField(string label, string name, string value, bool required, string helpText, string type = "text")
+    {
+        Label = label;
+        Name = name;
+        Value = value;
+        OriginalValue = value;
+        Required = required;
+        HelpText = helpText;
+        Type = type;
+    }
+
+    // TODO JSON parsing from string to objects again probably won't work out of the box because of the different field types.
+}

BTCPayServer.Abstractions/Form/TextField.cs

@@ -1,19 +0,0 @@
-namespace BTCPayServer.Abstractions.Form;
-
-public class TextField : Field
-{
-    public TextField(string label, string name, string value, bool required, string helpText)
-    {
-        this.Label = label;
-        this.Name = name;
-        this.Value = value;
-        this.OriginalValue = value;
-        this.Required = required;
-        this.HelpText = helpText;
-        this.Type = "text";
-    }
-
-    // TODO JSON parsing from string to objects again probably won't work out of the box because of the different field types. 
-    
-
-}

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -28,8 +28,8 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.3.12" />
-      <PackageReference Include="NBitcoin" Version="7.0.10" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.3.15" />
+      <PackageReference Include="NBitcoin" Version="7.0.14" />
       <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     </ItemGroup>
   <ItemGroup>

BTCPayServer.Client/BTCPayServerClient.Apps.cs

@@ -19,6 +19,17 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Post), token);
             return await HandleResponse<PointOfSaleAppData>(response);
         }
+        
+        public virtual async Task<CrowdfundAppData> CreateCrowdfundApp(string storeId,
+            CreateCrowdfundAppRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/apps/crowdfund", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<CrowdfundAppData>(response);
+        }
 
         public virtual async Task<PointOfSaleAppData> UpdatePointOfSaleApp(string appId,
             CreatePointOfSaleAppRequest request, CancellationToken token = default)

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -95,6 +95,24 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Get), token);
             return await HandleResponse<LightningInvoiceData>(response);
         }
+        
+        public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string cryptoCode,
+            bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (pendingOnly is bool v)
+            {
+                queryPayload.Add("pendingOnly", v.ToString());
+            }
+            if (offsetIndex is > 0)
+            {
+                queryPayload.Add("offsetIndex", offsetIndex);
+            }
+
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices", queryPayload), token);
+            return await HandleResponse<LightningInvoiceData[]>(response);
+        }
 
         public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
             CancellationToken token = default)

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -65,7 +65,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<string>(response);
         }
 
-        public virtual async Task PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
+        public virtual async Task<LightningPaymentData> PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -73,7 +73,7 @@ namespace BTCPayServer.Client
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices/pay", bodyPayload: request,
                     method: HttpMethod.Post), token);
-            await HandleResponse(response);
+            return await HandleResponse<LightningPaymentData>(response);
         }
 
         public virtual async Task<LightningPaymentData> GetLightningPayment(string storeId, string cryptoCode,
@@ -97,6 +97,24 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Get), token);
             return await HandleResponse<LightningInvoiceData>(response);
         }
+        
+        public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string storeId, string cryptoCode,
+            bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (pendingOnly is bool v)
+            {
+                queryPayload.Add("pendingOnly", v.ToString());
+            }
+            if (offsetIndex is > 0)
+            {
+                queryPayload.Add("offsetIndex", offsetIndex);
+            }
+
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", queryPayload), token);
+            return await HandleResponse<LightningInvoiceData[]>(response);
+        }
 
         public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
             CreateLightningInvoiceRequest request, CancellationToken token = default)

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.Objects.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+using NBitcoin;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<OnChainWalletObjectData> GetOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId, bool? includeNeighbourData = null, CancellationToken token = default)
+        {
+            Dictionary<string, object> parameters = new Dictionary<string, object>();
+            if (includeNeighbourData is bool v)
+                parameters.Add("includeNeighbourData", v);
+            var response =
+            await _httpClient.SendAsync(
+            CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}", parameters, method: HttpMethod.Get), token);
+            try
+            {
+                return await HandleResponse<OnChainWalletObjectData>(response);
+            }
+            catch (GreenfieldAPIException err) when (err.APIError.Code == "wallet-object-not-found")
+            {
+                return null;
+            }
+        }
+        public virtual async Task<OnChainWalletObjectData[]> GetOnChainWalletObjects(string storeId, string cryptoCode, GetWalletObjectsRequest query = null, CancellationToken token = default)
+        {
+            Dictionary<string, object> parameters = new Dictionary<string, object>();
+            if (query?.Type is string s)
+                parameters.Add("type", s);
+            if (query?.Ids is string[] ids)
+                parameters.Add("ids", ids);
+            if (query?.IncludeNeighbourData is bool v)
+                parameters.Add("includeNeighbourData", v);
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects", parameters, method:HttpMethod.Get), token);
+            return await HandleResponse<OnChainWalletObjectData[]>(response);
+        }
+        public virtual async Task RemoveOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}", method:HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+        public virtual async Task<OnChainWalletObjectData> AddOrUpdateOnChainWalletObject(string storeId, string cryptoCode, AddOnChainWalletObjectRequest request,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects", method:HttpMethod.Post, bodyPayload: request), token);
+            return await HandleResponse<OnChainWalletObjectData>(response);
+        }
+        public virtual async Task AddOrUpdateOnChainWalletLink(string storeId, string cryptoCode,
+            OnChainWalletObjectId objectId,
+            AddOnChainWalletObjectLinkRequest request = null,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}/links", method:HttpMethod.Post, bodyPayload: request), token);
+            await HandleResponse(response);
+        }
+        public virtual async Task RemoveOnChainWalletLinks(string storeId, string cryptoCode,
+            OnChainWalletObjectId objectId,
+            OnChainWalletObjectId link,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}/links/{link.Type}/{link.Id}", method:HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.PaymentRequests.cs

@@ -37,6 +37,20 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
+        public virtual async Task<Client.Models.InvoiceData> PayPaymentRequest(string storeId, string paymentRequestId, PayPaymentRequestRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            if (storeId is null)
+                throw new ArgumentNullException(nameof(storeId));
+            if (paymentRequestId is null)
+                throw new ArgumentNullException(nameof(paymentRequestId));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}/pay", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<Client.Models.InvoiceData>(response);
+        }
+
         public virtual async Task<PaymentRequestData> CreatePaymentRequest(string storeId,
             CreatePaymentRequestRequest request, CancellationToken token = default)
         {

BTCPayServer.Client/BTCPayServerClient.PullPayments.cs

@@ -53,6 +53,16 @@ namespace BTCPayServer.Client
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", bodyPayload: payoutRequest, method: HttpMethod.Post), cancellationToken);
             return await HandleResponse<PayoutData>(response);
         } 
+        public virtual async Task<PayoutData> GetPullPaymentPayout(string pullPaymentId, string payoutId, CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts/{payoutId}", method: HttpMethod.Get), cancellationToken);
+            return await HandleResponse<PayoutData>(response);
+        } 
+        public virtual async Task<PayoutData> GetStorePayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payouts/{payoutId}", method: HttpMethod.Get), cancellationToken);
+            return await HandleResponse<PayoutData>(response);
+        } 
         public virtual async Task<PayoutData> CreatePayout(string storeId, CreatePayoutThroughStoreRequest payoutRequest, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payouts", bodyPayload: payoutRequest, method: HttpMethod.Post), cancellationToken);
@@ -69,7 +79,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<PayoutData>(response);
         }
 
-        public async Task MarkPayoutPaid(string storeId, string payoutId,
+        public virtual async Task MarkPayoutPaid(string storeId, string payoutId,
             CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(
@@ -78,5 +88,14 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Post), cancellationToken);
             await HandleResponse(response);
         }
+        public virtual async Task MarkPayout(string storeId, string payoutId, MarkPayoutRequest request,
+            CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest(
+                    $"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark",
+                    method: HttpMethod.Post, bodyPayload: request), cancellationToken);
+            await HandleResponse(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreRatesConfiguration.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<StoreRateConfiguration> GetStoreRateConfiguration(string storeId,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/rates/configuration", method: HttpMethod.Get),
+                token);
+            return await HandleResponse<StoreRateConfiguration>(response);
+        }
+
+        public virtual async Task<List<RateSource>> GetRateSources(
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"misc/rate-sources", method: HttpMethod.Get),
+                token);
+            return await HandleResponse<List<RateSource>>(response);
+        }
+
+        public virtual async Task<StoreRateConfiguration> UpdateStoreRateConfiguration(string storeId,
+            StoreRateConfiguration request,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/rates/configuration", bodyPayload: request,
+                    method: HttpMethod.Put),
+                token);
+            return await HandleResponse<StoreRateConfiguration>(response);
+        }
+
+        public virtual async Task<List<StoreRatePreviewResult>> PreviewUpdateStoreRateConfiguration(string storeId,
+            StoreRateConfiguration request,
+            string[] currencyPair,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/rates/configuration/preview", bodyPayload: request,
+                    queryPayload: new Dictionary<string, object>() {{"currencyPair", currencyPair}},
+                    method: HttpMethod.Post),
+                token);
+            return await HandleResponse<List<StoreRatePreviewResult>>(response);
+        }
+    }
+}

BTCPayServer.Client/Models/CreateAppRequest.cs

@@ -1,3 +1,4 @@
+using System;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
@@ -36,6 +37,48 @@ namespace BTCPayServer.Client.Models
         public string RedirectUrl { get; set; } = null;
         public bool? RedirectAutomatically { get; set; } = null;
         public bool? RequiresRefundEmail { get; set; } = null;
+        public string FormId { get; set; } = null;
         public string EmbeddedCSS { get; set; } = null;
+        public CheckoutType? CheckoutType { get; set; } = null;
+    }
+
+    public enum CrowdfundResetEvery
+    {
+        Never,
+        Hour,
+        Day,
+        Month,
+        Year
+    }
+
+    public class CreateCrowdfundAppRequest : CreateAppRequest
+    {
+        public string Title { get; set; } = null;
+        public bool? Enabled { get; set; } = null;
+        public bool? EnforceTargetAmount { get; set; } = null;
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? StartDate { get; set; } = null;
+        public string TargetCurrency { get; set; } = null;
+        public string Description { get; set; } = null;
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? EndDate { get; set; } = null;
+        public decimal? TargetAmount { get; set; } = null;
+        public string CustomCSSLink { get; set; } = null;
+        public string MainImageUrl { get; set; } = null;
+        public string EmbeddedCSS { get; set; } = null;
+        public string NotificationUrl { get; set; } = null;
+        public string Tagline { get; set; } = null;
+        public string PerksTemplate { get; set; } = null;
+        public bool? SoundsEnabled { get; set; } = null;
+        public string DisqusShortname { get; set; } = null;
+        public bool? AnimationsEnabled { get; set; } = null;
+        public int? ResetEveryAmount { get; set; } = null;
+        [JsonConverter(typeof(StringEnumConverter))]
+        public CrowdfundResetEvery ResetEvery { get; set; } = CrowdfundResetEvery.Never;
+        public bool? DisplayPerksValue { get; set; } = null;
+        public bool? DisplayPerksRanking { get; set; } = null;
+        public bool? SortPerksByPopularity { get; set; } = null;
+        public string[] Sounds { get; set; } = null;
+        public string[] AnimationColors { get; set; } = null;
     }
 }

BTCPayServer.Client/Models/InvoiceData.cs

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

BTCPayServer.Client/Models/LabelData.cs

@@ -1,9 +1,11 @@
+using System;
 using System.Collections.Generic;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client.Models
 {
+    [Obsolete]
     public class LabelData
     {
         public string Type { get; set; }

BTCPayServer.Client/Models/LightningInvoiceData.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using BTCPayServer.Client.JsonConverters;
 using BTCPayServer.Lightning;
 using Newtonsoft.Json;
@@ -26,5 +27,8 @@ namespace BTCPayServer.Client.Models
 
         [JsonConverter(typeof(LightMoneyJsonConverter))]
         public LightMoney AmountReceived { get; set; }
+
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public Dictionary<ulong, string> CustomRecords { get; set; }
     }
 }

BTCPayServer.Client/Models/LightningNodeInformationData.cs

@@ -9,6 +9,13 @@ namespace BTCPayServer.Client.Models
         [JsonProperty("nodeURIs", ItemConverterType = typeof(NodeUriJsonConverter))]
         public NodeInfo[] NodeURIs { get; set; }
         public int BlockHeight { get; set; }
+        public string Alias { get; set; }
+        public string Color { get; set; }
+        public string Version { get; set; }
+        public long? PeersCount { get; set; }
+        public long? ActiveChannelsCount { get; set; }
+        public long? InactiveChannelsCount { get; set; }
+        public long? PendingChannelsCount { get; set; }
     }
 
     public class LightningChannelData

BTCPayServer.Client/Models/MarkPayoutRequest.cs

@@ -0,0 +1,14 @@
+#nullable enable
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models;
+
+public class MarkPayoutRequest
+{
+    [JsonConverter(typeof(StringEnumConverter))]
+    public PayoutState State { get; set; } = PayoutState.Completed;
+
+    public JObject? PaymentProof { get; set; }
+}

BTCPayServer.Client/Models/OnChainWalletTransactionData.cs

@@ -4,16 +4,94 @@ using BTCPayServer.JsonConverters;
 using NBitcoin;
 using NBitcoin.JsonConverters;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client.Models
 {
+    public class OnChainWalletObjectId
+    {
+        public OnChainWalletObjectId()
+        {
+
+        }
+        public OnChainWalletObjectId(string type, string id)
+        {
+            Type = type;
+            Id = id;
+        }
+        public string Type { get; set; }
+        public string Id { get; set; }
+    }
+    public class AddOnChainWalletObjectLinkRequest : OnChainWalletObjectId
+    {
+        public AddOnChainWalletObjectLinkRequest()
+        {
+
+        }
+        public AddOnChainWalletObjectLinkRequest(string objectType, string objectId) : base(objectType, objectId)
+        {
+
+        }
+        public JObject Data { get; set; }
+    }
+
+    public class GetWalletObjectsRequest
+    {
+        public string Type { get; set; }
+        public string[] Ids { get; set; }
+        public bool? IncludeNeighbourData { get; set; }
+    }
+
+    public class AddOnChainWalletObjectRequest : OnChainWalletObjectId
+    {
+        public AddOnChainWalletObjectRequest()
+        {
+
+        }
+        public AddOnChainWalletObjectRequest(string objectType, string objectId) : base(objectType, objectId)
+        {
+
+        }
+        public JObject Data { get; set; }
+    }
+
+    public class OnChainWalletObjectData : OnChainWalletObjectId
+    {
+        public OnChainWalletObjectData()
+        {
+
+        }
+        public OnChainWalletObjectData(string type, string id) : base(type, id)
+        {
+
+        }
+
+        public class OnChainWalletObjectLink : OnChainWalletObjectId
+        {
+            public OnChainWalletObjectLink()
+            {
+
+            }
+            public OnChainWalletObjectLink(string type, string id) : base(type, id)
+            {
+
+            }
+            public JObject LinkData { get; set; }
+            public JObject ObjectData { get; set; }
+        }
+        public JObject Data { get; set; }
+        public OnChainWalletObjectLink[] Links { get; set; }
+    }
+
     public class OnChainWalletTransactionData
     {
         [JsonConverter(typeof(UInt256JsonConverter))]
         public uint256 TransactionHash { get; set; }
 
         public string Comment { get; set; }
+#pragma warning disable CS0612 // Type or member is obsolete
         public Dictionary<string, LabelData> Labels { get; set; } = new Dictionary<string, LabelData>();
+#pragma warning restore CS0612 // Type or member is obsolete
 
         [JsonConverter(typeof(NumericStringJsonConverter))]
         public decimal Amount { get; set; }

BTCPayServer.Client/Models/OnChainWalletUTXOData.cs

@@ -15,7 +15,9 @@ namespace BTCPayServer.Client.Models
         [JsonConverter(typeof(OutpointJsonConverter))]
         public OutPoint Outpoint { get; set; }
         public string Link { get; set; }
+#pragma warning disable CS0612 // Type or member is obsolete
         public Dictionary<string, LabelData> Labels { get; set; }
+#pragma warning restore CS0612 // Type or member is obsolete
         [JsonConverter(typeof(DateTimeToUnixTimeConverter))]
         public DateTimeOffset Timestamp { get; set; }
         [JsonConverter(typeof(KeyPathJsonConverter))]

BTCPayServer.Client/Models/PayLightningInvoiceRequest.cs

@@ -1,3 +1,4 @@
+using System;
 using BTCPayServer.Client.JsonConverters;
 using BTCPayServer.JsonConverters;
 using BTCPayServer.Lightning;
@@ -19,5 +20,8 @@ namespace BTCPayServer.Client.Models
     
         [JsonConverter(typeof(LightMoneyJsonConverter))]
         public LightMoney Amount { get; set; }
+
+        [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
+        public TimeSpan? SendTimeout { get; set; }
     }
 }

BTCPayServer.Client/Models/PayPaymentRequestRequest.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class PayPaymentRequestRequest
+    {
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal? Amount { get; set; }
+        public bool? AllowPendingInvoiceReuse { get; set; }
+    }
+}

BTCPayServer.Client/Models/PaymentRequestBaseData.cs

@@ -24,5 +24,9 @@ namespace BTCPayServer.Client.Models
 
         [JsonExtensionData]
         public IDictionary<string, JToken> AdditionalData { get; set; }
+
+        public string FormId { get; set; }
+
+        public string FormResponse { get; set; }
     }
 }

BTCPayServer.Client/Models/PaymentRequestData.cs

@@ -12,7 +12,6 @@ namespace BTCPayServer.Client.Models
         public DateTimeOffset CreatedTime { get; set; }
         public string Id { get; set; }
         public bool Archived { get; set; }
-
         public enum PaymentRequestStatus
         {
             Pending = 0,

BTCPayServer.Client/Models/PayoutData.cs

@@ -2,6 +2,7 @@ using System;
 using BTCPayServer.JsonConverters;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client.Models
 {
@@ -29,5 +30,6 @@ namespace BTCPayServer.Client.Models
         [JsonConverter(typeof(StringEnumConverter))]
         public PayoutState State { get; set; }
         public int Revision { get; set; }
+        public JObject PaymentProof { get; set; }
     }
 }

BTCPayServer.Client/Models/PointOfSaleAppData.cs

@@ -17,4 +17,9 @@ namespace BTCPayServer.Client.Models
     {
         // We can add POS specific things here later
     }
+
+    public class CrowdfundAppData : AppDataBase
+    {
+        // We can add Crowdfund specific things here later
+    }
 }

BTCPayServer.Client/Models/RateSource.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Client.Models;
+
+public class RateSource
+{
+    public string Id { get; set; }
+    public string Name { get; set; }
+}

BTCPayServer.Client/Models/StoreBaseData.cs

@@ -31,6 +31,8 @@ namespace BTCPayServer.Client.Models
         public bool AnyoneCanCreateInvoice { get; set; }
         public string DefaultCurrency { get; set; }
         public bool RequiresRefundEmail { get; set; }
+        [JsonConverter(typeof(StringEnumConverter))]
+        public CheckoutType CheckoutType { get; set; }
         public bool LightningAmountInSatoshi { get; set; }
         public bool LightningPrivateRouteHints { get; set; }
         public bool OnChainWithLnInvoiceFallback { get; set; }
@@ -66,6 +68,12 @@ namespace BTCPayServer.Client.Models
         public IDictionary<string, JToken> AdditionalData { get; set; }
     }
 
+    public enum CheckoutType
+    {
+        V1,
+        V2
+    }
+
     public enum NetworkFeeMode
     {
         MultiplePaymentsOnly,

BTCPayServer.Client/Models/StoreRateConfiguration.cs

@@ -0,0 +1,10 @@
+namespace BTCPayServer.Client.Models
+{
+    public class StoreRateConfiguration
+    {
+        public decimal Spread { get; set; }
+        public bool IsCustomScript { get; set; }
+        public string EffectiveScript { get; set; }
+        public string PreferredSource { get; set; }
+    }
+}

BTCPayServer.Client/Models/StoreRatePreviewResult.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models;
+
+public class StoreRatePreviewResult
+{
+    public string CurrencyPair { get; set; }
+    public decimal? Rate { get; set; }
+    public List<string> Errors { get; set; }
+}

BTCPayServer.Client/Models/StoreRateResult.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Client.Models;
+
+public class StoreRateResult
+{
+    public string CurrencyPair { get; set; }
+    public decimal Rate { get; set; }
+}

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.MonetaryUnit.cs

@@ -1,28 +0,0 @@
-using NBitcoin;
-using NBXplorer;
-
-namespace BTCPayServer
-{
-    public partial class BTCPayNetworkProvider
-    {
-        public void InitMonetaryUnit()
-        {
-            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("MUE");
-            Add(new BTCPayNetwork()
-            {
-                CryptoCode = nbxplorerNetwork.CryptoCode,
-                DisplayName = "MonetaryUnit",
-                BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://explorer.monetaryunit.org/#/MUE/mainnet/tx/{0}" : "https://explorer.monetaryunit.org/#/MUE/mainnet/tx/{0}",
-                NBXplorerNetwork = nbxplorerNetwork,
-                DefaultRateRules = new[]
-                {
-                                "MUE_X = MUE_BTC * BTC_X",
-                                "MUE_BTC = bittrex(MUE_BTC)"
-                },
-                CryptoImagePath = "imlegacy/monetaryunit.png",
-                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("31'") : new KeyPath("1'")
-            });
-        }
-    }
-}

BTCPayServer.Common/BTCPayNetwork.cs

@@ -137,6 +137,7 @@ namespace BTCPayServer
 
         public string CryptoImagePath { get; set; }
         public string[] DefaultRateRules { get; set; } = Array.Empty<string>();
+
         public override string ToString()
         {
             return CryptoCode;

BTCPayServer.Common/BTCPayNetworkProvider.cs

@@ -58,7 +58,7 @@ namespace BTCPayServer
             InitZcash();
             InitChaincoin();
             // InitArgoneum();//their rate source is down 9/15/20.
-            InitMonetaryUnit();
+            // InitMonetaryUnit(); Not supported from Bittrex from 11/23/2022, dead shitcoin
 
             // Assume that electrum mappings are same as BTC if not specified
             foreach (var network in _Networks.Values.OfType<BTCPayNetwork>())

BTCPayServer.Common/BTCPayServer.Common.csproj

@@ -4,7 +4,8 @@
 
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="NBXplorer.Client" Version="4.2.0" />
+    <PackageReference Include="NBXplorer.Client" Version="4.2.1" />
+    <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.18" />
   </ItemGroup>
   <ItemGroup Condition="'$(Altcoins)' != 'true'">
     <Compile Remove="Altcoins\**\*.cs"></Compile>

BTCPayServer.Common/Logging/ConsoleLogger.cs

@@ -180,7 +180,7 @@ namespace BTCPayServer.Logging
             logBuilder.Append(": ");
             var lenAfter = logBuilder.ToString().Length;
             while (lenAfter++ < 18)
-                logBuilder.Append(" ");
+                logBuilder.Append(' ');
             // scope information
             GetScopeInformation(logBuilder);
 

BTCPayServer.Data/ApplicationDbContext.cs

@@ -59,7 +59,11 @@ namespace BTCPayServer.Data
         public DbSet<U2FDevice> U2FDevices { get; set; }
         public DbSet<Fido2Credential> Fido2Credentials { get; set; }
         public DbSet<UserStore> UserStore { get; set; }
+        [Obsolete]
         public DbSet<WalletData> Wallets { get; set; }
+        public DbSet<WalletObjectData> WalletObjects { get; set; }
+        public DbSet<WalletObjectLinkData> WalletObjectLinks { get; set; }
+        [Obsolete]
         public DbSet<WalletTransactionData> WalletTransactions { get; set; }
         public DbSet<WebhookDeliveryData> WebhookDeliveries { get; set; }
         public DbSet<WebhookData> Webhooks { get; set; }
@@ -109,7 +113,11 @@ namespace BTCPayServer.Data
             Fido2Credential.OnModelCreating(builder);
             BTCPayServer.Data.UserStore.OnModelCreating(builder);
             //WalletData.OnModelCreating(builder);
+            WalletObjectData.OnModelCreating(builder, Database);
+            WalletObjectLinkData.OnModelCreating(builder, Database);
+#pragma warning disable CS0612 // Type or member is obsolete
             WalletTransactionData.OnModelCreating(builder);
+#pragma warning restore CS0612 // Type or member is obsolete
             WebhookDeliveryData.OnModelCreating(builder);
             LightningAddressData.OnModelCreating(builder);
             PayoutProcessorData.OnModelCreating(builder);

BTCPayServer.Data/BTCPayServer.Data.csproj

@@ -3,11 +3,11 @@
   <Import Project="../Build/Common.csproj" />
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.7">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.9">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="6.0.7" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="6.0.9" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\BTCPayServer.Abstractions\BTCPayServer.Abstractions.csproj" />

BTCPayServer.Data/Data/FormData.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace BTCPayServer.Data.Data;
+
+public class FormData
+{
+    public string Id { get; set; }
+    public string Name { get; set; }
+    public string Config { get; set; }
+}

BTCPayServer.Data/Data/WalletData.cs

@@ -1,7 +1,9 @@
+using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Data
 {
+    [Obsolete]
     public class WalletData
     {
         [System.ComponentModel.DataAnnotations.Key]

BTCPayServer.Data/Data/WalletObjectData.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace BTCPayServer.Data
+{
+    public class WalletObjectData
+    {
+        public class Types
+        {
+            public const string Label = "label";
+            public const string Tx = "tx";
+            public const string Payjoin = "payjoin";
+            public const string Invoice = "invoice";
+            public const string PaymentRequest = "payment-request";
+            public const string App = "app";
+            public const string PayjoinExposed = "pj-exposed";
+            public const string Payout = "payout";
+            public const string PullPayment = "pull-payment";
+        }
+        public string WalletId { get; set; }
+        public string Type { get; set; }
+        public string Id { get; set; }
+        public string Data { get; set; }
+
+        public List<WalletObjectLinkData> ChildLinks { get; set; }
+        public List<WalletObjectLinkData> ParentLinks { get; set; }
+
+        public IEnumerable<(string type, string id, string linkdata, string objectdata)> GetLinks()
+        {
+            if (ChildLinks is not null)
+                foreach (var c in ChildLinks)
+                {
+                    yield return (c.ChildType, c.ChildId, c.Data, c.Child?.Data);
+                }
+            if (ParentLinks is not null)
+                foreach (var c in ParentLinks)
+                {
+                    yield return (c.ParentType, c.ParentId, c.Data, c.Parent?.Data);
+                }
+        }
+
+        public IEnumerable<WalletObjectData> GetNeighbours()
+        {
+            if (ChildLinks != null)
+                foreach (var c in ChildLinks)
+                {
+                    if (c.Child != null)
+                        yield return c.Child;
+                }
+            if (ParentLinks != null)
+                foreach (var c in ParentLinks)
+                {
+                    if (c.Parent != null)
+                        yield return c.Parent;
+                }
+        }
+
+        internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
+        {
+            builder.Entity<WalletObjectData>().HasKey(o =>
+            new
+            {
+                o.WalletId,
+                o.Type,
+                o.Id,
+            });
+            builder.Entity<WalletObjectData>().HasIndex(o =>
+            new
+            {
+                o.Type,
+                o.Id
+            });
+
+            if (databaseFacade.IsNpgsql())
+            {
+                builder.Entity<WalletObjectData>()
+                                .Property(o => o.Data)
+                                .HasColumnType("JSONB");
+            }
+        }
+    }
+}

BTCPayServer.Data/Data/WalletObjectLinkData.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace BTCPayServer.Data
+{
+    public class WalletObjectLinkData
+    {
+        public string WalletId { get; set; }
+        public string ParentType { get; set; }
+        public string ParentId { get; set; }
+        public string ChildType { get; set; }
+        public string ChildId { get; set; }
+        public string Data { get; set; }
+
+        public WalletObjectData Parent { get; set; }
+        public WalletObjectData Child { get; set; }
+
+        internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
+        {
+            builder.Entity<WalletObjectLinkData>().HasKey(o =>
+            new
+            {
+                o.WalletId,
+                o.ParentType,
+                o.ParentId,
+                o.ChildType,
+                o.ChildId,
+            });
+            builder.Entity<WalletObjectLinkData>().HasIndex(o => new
+            {
+                o.WalletId,
+                o.ChildType,
+                o.ChildId,
+            });
+
+            builder.Entity<WalletObjectLinkData>()
+                .HasOne(o => o.Parent)
+                .WithMany(o => o.ChildLinks)
+                .HasForeignKey(o => new { o.WalletId, o.ParentType, o.ParentId })
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.Entity<WalletObjectLinkData>()
+                .HasOne(o => o.Child)
+                .WithMany(o => o.ParentLinks)
+                .HasForeignKey(o => new { o.WalletId, o.ChildType, o.ChildId })
+                .OnDelete(DeleteBehavior.Cascade);
+
+            if (databaseFacade.IsNpgsql())
+            {
+                builder.Entity<WalletObjectLinkData>()
+                                .Property(o => o.Data)
+                                .HasColumnType("JSONB");
+            }
+        }
+    }
+}

BTCPayServer.Data/Data/WalletTransactionData.cs

@@ -1,7 +1,9 @@
+using System;
 using Microsoft.EntityFrameworkCore;
 
 namespace BTCPayServer.Data
 {
+    [Obsolete]
     public class WalletTransactionData
     {
         public string WalletDataId { get; set; }

BTCPayServer.Data/Migrations/20220929132704_label.cs

@@ -0,0 +1,81 @@
+// <auto-generated />
+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("20220929132704_label")]
+    public partial class label : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "WalletObjects",
+                columns: table => new
+                {
+                    WalletId = table.Column<string>(type: "TEXT", nullable: false),
+                    Type = table.Column<string>(type: "TEXT", nullable: false),
+                    Id = table.Column<string>(type: "TEXT", nullable: false),
+                    Data = table.Column<string>(type: migrationBuilder.IsNpgsql() ? "JSONB" : "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WalletObjects", x => new { x.WalletId, x.Type, x.Id });
+                });
+            migrationBuilder.CreateIndex(
+                name: "IX_WalletObjects_Type_Id",
+                table: "WalletObjects",
+                columns: new[] { "Type", "Id" });
+
+            migrationBuilder.CreateTable(
+                name: "WalletObjectLinks",
+                columns: table => new
+                {
+                    WalletId = table.Column<string>(type: "TEXT", nullable: false),
+                    ParentType = table.Column<string>(type: "TEXT", nullable: false),
+                    ParentId = table.Column<string>(type: "TEXT", nullable: false),
+                    ChildType = table.Column<string>(type: "TEXT", nullable: false),
+                    ChildId = table.Column<string>(type: "TEXT", nullable: false),
+                    Data = table.Column<string>(type: migrationBuilder.IsNpgsql() ? "JSONB" : "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WalletObjectLinks", x => new { x.WalletId, x.ParentType, x.ParentId, x.ChildType, x.ChildId });
+                    table.ForeignKey(
+                        name: "FK_WalletObjectLinks_WalletObjects_WalletId_ChildType_ChildId",
+                        columns: x => new { x.WalletId, x.ChildType, x.ChildId },
+                        principalTable: "WalletObjects",
+                        principalColumns: new[] { "WalletId", "Type", "Id" },
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_WalletObjectLinks_WalletObjects_WalletId_ParentType_ParentId",
+                        columns: x => new { x.WalletId, x.ParentType, x.ParentId },
+                        principalTable: "WalletObjects",
+                        principalColumns: new[] { "WalletId", "Type", "Id" },
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WalletObjectLinks_WalletId_ChildType_ChildId",
+                table: "WalletObjectLinks",
+                columns: new[] { "WalletId", "ChildType", "ChildId" });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "WalletObjectLinks");
+
+            migrationBuilder.DropTable(
+                name: "WalletObjects");
+        }
+    }
+}

BTCPayServer.Data/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -16,7 +16,7 @@ namespace BTCPayServer.Migrations
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "6.0.1");
+            modelBuilder.HasAnnotation("ProductVersion", "6.0.9");
 
             modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
                 {
@@ -189,6 +189,7 @@ namespace BTCPayServer.Migrations
                         .HasColumnType("TEXT");
 
                     b.Property<string>("Name")
+                        .IsRequired()
                         .HasMaxLength(50)
                         .HasColumnType("TEXT");
 
@@ -845,6 +846,54 @@ namespace BTCPayServer.Migrations
                     b.ToTable("Wallets");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.WalletObjectData", b =>
+                {
+                    b.Property<string>("WalletId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("WalletId", "Type", "Id");
+
+                    b.HasIndex("Type", "Id");
+
+                    b.ToTable("WalletObjects");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.WalletObjectLinkData", b =>
+                {
+                    b.Property<string>("WalletId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ParentType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChildType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChildId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("WalletId", "ParentType", "ParentId", "ChildType", "ChildId");
+
+                    b.HasIndex("WalletId", "ChildType", "ChildId");
+
+                    b.ToTable("WalletObjectLinks");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.WalletTransactionData", b =>
                 {
                     b.Property<string>("WalletDataId")
@@ -1333,6 +1382,25 @@ namespace BTCPayServer.Migrations
                     b.Navigation("StoreData");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.WalletObjectLinkData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.WalletObjectData", "Child")
+                        .WithMany("ParentLinks")
+                        .HasForeignKey("WalletId", "ChildType", "ChildId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("BTCPayServer.Data.WalletObjectData", "Parent")
+                        .WithMany("ChildLinks")
+                        .HasForeignKey("WalletId", "ParentType", "ParentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Child");
+
+                    b.Navigation("Parent");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.WalletTransactionData", b =>
                 {
                     b.HasOne("BTCPayServer.Data.WalletData", "WalletData")
@@ -1475,6 +1543,13 @@ namespace BTCPayServer.Migrations
                     b.Navigation("WalletTransactions");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.WalletObjectData", b =>
+                {
+                    b.Navigation("ChildLinks");
+
+                    b.Navigation("ParentLinks");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.WebhookData", b =>
                 {
                     b.Navigation("Deliveries");

BTCPayServer.PluginPacker/BTCPayServer.PluginPacker.csproj

@@ -26,6 +26,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+      <PackageReference Include="McMaster.NETCore.Plugins.Mvc" Version="1.4.0" />
       <ProjectReference Include="..\BTCPayServer.Abstractions\BTCPayServer.Abstractions.csproj" />
       <None Include="icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>

BTCPayServer.PluginPacker/Program.cs

@@ -8,6 +8,7 @@ using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
 using BTCPayServer.Abstractions.Contracts;
+using McMaster.NETCore.Plugins;
 using NBitcoin.Crypto;
 using NBitcoin.DataEncoders;
 using NBitcoin.Secp256k1;
@@ -33,7 +34,8 @@ namespace BTCPayServer.PluginPacker
                 throw new Exception($"{rootDLLPath} could not be found");
             }
 
-            var assembly = Assembly.LoadFrom(rootDLLPath);
+            var plugin = PluginLoader.CreateFromAssemblyFile(rootDLLPath, false, new[] { typeof(IBTCPayServerPlugin) });
+            var assembly = plugin.LoadAssembly(name);
             var extension = GetAllExtensionTypesFromAssembly(assembly).FirstOrDefault();
             if (extension is null)
             {

BTCPayServer.Plugins.Test/BTCPayServer.Plugins.Test.csproj

@@ -13,7 +13,7 @@
       <EmbeddedResource Include="Resources\**" />
     </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.7">
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.9">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>

BTCPayServer.Rating/BTCPayServer.Rating.csproj

@@ -4,9 +4,9 @@
 
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.3.1" />
     <PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.9" />
-    <PackageReference Include="NBitcoin" Version="7.0.10" />
+    <PackageReference Include="NBitcoin" Version="7.0.14" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="DigitalRuby.ExchangeSharp" Version="1.0.2" />
   </ItemGroup>

BTCPayServer.Rating/CurrencyPair.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using BTCPayServer.Services.Rates;
 
 namespace BTCPayServer.Rating
@@ -56,6 +57,13 @@ namespace BTCPayServer.Rating
                     }
                 }
             }
+            else if (splitted.Length > 2)
+            {
+                // Some shitcoin have _ their own ticker name... Since we don't care about those, let's
+                // parse it anyway assuming the first part is one currency.
+                value = new CurrencyPair(splitted[0], string.Join("_", splitted.Skip(1).ToArray()));
+                return true;
+            }
 
             return false;
         }

BTCPayServer.Rating/Providers/ExchangeSharpRateProvider.cs

@@ -44,9 +44,6 @@ namespace BTCPayServer.Services.Rates
         {
             if (notFoundSymbols.TryGetValue(ticker.Key, out _))
                 return null;
-            if (ticker.Key.Contains("XMR"))
-            {
-            }
             try
             {
                 CurrencyPair pair;

BTCPayServer.Rating/Providers/KrakenExchangeRateProvider.cs

@@ -168,7 +168,7 @@ namespace BTCPayServer.Services.Rates
             sb.Append(url);
             if (payload != null)
             {
-                sb.Append("?");
+                sb.Append('?');
                 sb.Append(String.Join('&', payload.Select(kv => $"{kv.Key}={kv.Value}").OfType<object>().ToArray()));
             }
             var request = new HttpRequestMessage(HttpMethod.Get, sb.ToString());

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
   <Import Project="../Build/Common.csproj" />
   <PropertyGroup>
     <IsPackable>false</IsPackable>
@@ -19,12 +19,12 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
     <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="104.0.5112.7900" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="105.0.5195.5200" />
+    <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>

BTCPayServer.Tests/CheckoutUITests.cs

@@ -30,7 +30,7 @@ namespace BTCPayServer.Tests
             s.AddDerivationScheme();
             s.GoToStore(StoreNavPages.CheckoutAppearance);
             s.Driver.FindElement(By.Id("RequiresRefundEmail")).Click();
-            s.Driver.FindElement(By.Name("command")).Click();
+            s.Driver.FindElement(By.Id("Save")).Click();
 
             var emailAlreadyThereInvoiceId = s.CreateInvoice(100, "USD", "a@g.com");
             s.GoToInvoiceCheckout(emailAlreadyThereInvoiceId);

BTCPayServer.Tests/Checkoutv2Tests.cs

@@ -0,0 +1,212 @@
+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;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    [Trait("Selenium", "Selenium")]
+    [Collection(nameof(NonParallelizableCollectionDefinition))]
+    public class CheckoutV2Tests : UnitTestBase
+    {
+        private const int TestTimeout = TestUtils.TestTimeout;
+        
+        public CheckoutV2Tests(ITestOutputHelper helper) : base(helper)
+        {
+        }
+        
+        [Fact(Timeout = TestTimeout)]
+        [Trait("Lightning", "Lightning")]
+        public async Task CanConfigureCheckout()
+        {
+            using var s = CreateSeleniumTester();
+            s.Server.ActivateLightning();
+            await s.StartAsync();
+            s.GoToRegister();
+            s.RegisterNewUser(true);
+            s.CreateNewStore();
+            s.EnableCheckoutV2();
+            s.AddLightningNode();
+            s.AddDerivationScheme();
+
+            // Configure store url
+            var storeUrl = "https://satoshisteaks.com/";
+            s.GoToStore();
+            s.Driver.FindElement(By.Id("StoreWebsite")).SendKeys(storeUrl);
+            s.Driver.FindElement(By.Id("Save")).Click();
+            Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
+            
+            // Default payment method
+            var invoiceId = s.CreateInvoice(defaultPaymentMethod: "BTC_LightningLike");
+            s.GoToInvoiceCheckout(invoiceId);
+            
+            Assert.Equal(2, s.Driver.FindElements(By.CssSelector(".payment-method")).Count);
+            Assert.Contains("Lightning", s.Driver.WaitForElement(By.CssSelector(".payment-method.active")).Text);
+            Assert.DoesNotContain("LNURL", s.Driver.PageSource);
+            var payUrl = s.Driver.FindElement(By.CssSelector(".btn-primary")).GetAttribute("href");
+            Assert.StartsWith("lightning:", payUrl);
+            
+            // Lightning amount in Sats
+            Assert.Contains("BTC", s.Driver.FindElement(By.Id("AmountDue")).Text);
+            s.GoToHome();
+            s.GoToLightningSettings();
+            s.Driver.SetCheckbox(By.Id("LightningAmountInSatoshi"), true);
+            s.Driver.FindElement(By.Id("save")).Click();
+            Assert.Contains("BTC Lightning settings successfully updated", s.FindAlertMessage().Text);
+            s.GoToInvoiceCheckout(invoiceId);
+            Assert.Contains("Sats", s.Driver.FindElement(By.Id("AmountDue")).Text);
+            
+            // Expire
+            var expirySeconds = s.Driver.FindElement(By.Id("ExpirySeconds"));
+            expirySeconds.Clear();
+            expirySeconds.SendKeys("3");
+            s.Driver.FindElement(By.Id("Expire")).Click();
+
+            var paymentInfo = s.Driver.WaitForElement(By.Id("PaymentInfo"));
+            Assert.Contains("This invoice will expire in", paymentInfo.Text);
+            Assert.DoesNotContain("Please send", paymentInfo.Text);
+            TestUtils.Eventually(() =>
+            {
+                var expiredSection = s.Driver.FindElement(By.Id("expired"));
+                Assert.True(expiredSection.Displayed);
+                Assert.Contains("Invoice Expired", expiredSection.Text);
+            });
+            Assert.True(s.Driver.ElementDoesNotExist(By.Id("ReceiptLink")));
+            Assert.Equal(storeUrl, s.Driver.FindElement(By.Id("StoreLink")).GetAttribute("href"));
+            
+            // Test payment
+            s.GoToHome();
+            invoiceId = s.CreateInvoice();
+            s.GoToInvoiceCheckout(invoiceId);
+            
+            // Details
+            s.Driver.ToggleCollapse("PaymentDetails");
+            var details = s.Driver.FindElement(By.CssSelector(".payment-details"));
+            Assert.Contains("Total Price", details.Text);
+            Assert.Contains("Total Fiat", details.Text);
+            Assert.Contains("Exchange Rate", details.Text);
+            Assert.Contains("Amount Due", details.Text);
+            Assert.Contains("Recommended Fee", details.Text);
+            
+            // Pay partial amount
+            await Task.Delay(200);
+            var address = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-destination");
+            var 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);
+            });
+
+            // Mine
+            s.Driver.FindElement(By.Id("Mine")).Click();
+            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();
+            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);
+            });
+            s.Driver.FindElement(By.Id("ReceiptLink"));
+            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.FindElement(By.Id("Save")).Click();
+            Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
+            
+            invoiceId = s.CreateInvoice();
+            s.GoToInvoiceCheckout(invoiceId);
+            Assert.Empty(s.Driver.FindElements(By.CssSelector(".payment-method")));
+            payUrl = s.Driver.FindElement(By.CssSelector(".btn-primary")).GetAttribute("href");
+            Assert.StartsWith("bitcoin:", payUrl);
+            Assert.Contains("&LIGHTNING=", payUrl);
+            
+            // BIP21 with topup invoice (which is only available with Bitcoin onchain)
+            s.GoToHome();
+            invoiceId = s.CreateInvoice(amount: null);
+            s.GoToInvoiceCheckout(invoiceId);
+            Assert.Empty(s.Driver.FindElements(By.CssSelector(".payment-method")));
+            payUrl = s.Driver.FindElement(By.CssSelector(".btn-primary")).GetAttribute("href");
+            Assert.StartsWith("bitcoin:", payUrl);
+            Assert.DoesNotContain("&LIGHTNING=", payUrl);
+            
+            // Expiry message should not show amount for topup invoice
+            expirySeconds = s.Driver.FindElement(By.Id("ExpirySeconds"));
+            expirySeconds.Clear();
+            expirySeconds.SendKeys("5");
+            s.Driver.FindElement(By.Id("Expire")).Click();
+
+            paymentInfo = s.Driver.WaitForElement(By.Id("PaymentInfo"));
+            Assert.Contains("This invoice will expire in", paymentInfo.Text);
+            Assert.DoesNotContain("Please send", paymentInfo.Text);
+        }
+
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanUseCheckoutAsModal()
+        {
+            using var s = CreateSeleniumTester();
+            await s.StartAsync();
+            s.GoToRegister();
+            s.RegisterNewUser();
+            s.CreateNewStore();
+            s.EnableCheckoutV2();
+            s.GoToStore();
+            s.AddDerivationScheme();
+            var invoiceId = s.CreateInvoice(0.001m, "BTC", "a@x.com");
+            var invoice = await s.Server.PayTester.InvoiceRepository.GetInvoice(invoiceId);
+            s.Driver.Navigate()
+                .GoToUrl(new Uri(s.ServerUri, $"tests/index.html?invoice={invoiceId}"));
+            TestUtils.Eventually(() =>
+            {
+                Assert.True(s.Driver.FindElement(By.Name("btcpay")).Displayed);
+            });
+            await s.Server.ExplorerNode.SendToAddressAsync(BitcoinAddress.Create(invoice
+                    .GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike))
+                    .GetPaymentMethodDetails().GetPaymentDestination(), Network.RegTest),
+                new Money(0.001m, MoneyUnit.BTC));
+
+            IWebElement closebutton = null;
+            TestUtils.Eventually(() =>
+            {
+                var frameElement = s.Driver.FindElement(By.Name("btcpay"));
+                var iframe = s.Driver.SwitchTo().Frame(frameElement);
+                closebutton = iframe.FindElement(By.Id("close"));
+                Assert.True(closebutton.Displayed);
+            });
+            closebutton.Click();
+            s.Driver.AssertElementNotFound(By.Name("btcpay"));
+            Assert.Equal(s.Driver.Url,
+                new Uri(s.ServerUri, $"tests/index.html?invoice={invoiceId}").ToString());
+        }
+    }
+}

BTCPayServer.Tests/Dockerfile

@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/dotnet/sdk:6.0.101-bullseye-slim AS builder
+FROM mcr.microsoft.com/dotnet/sdk:6.0.401-bullseye-slim AS builder
 
 RUN apt-get update && apt-get install -y --no-install-recommends chromium-driver \
     && rm -rf /var/lib/apt/lists/*

BTCPayServer.Tests/Extensions.cs

@@ -125,6 +125,12 @@ retry:
 
             return el;
         }
+
+        public static void FillIn(this IWebElement el, string text)
+        {
+            el.Clear();
+            el.SendKeys(text);
+        }
         
         public static void ScrollTo(this IWebDriver driver, IWebElement element)
         {

BTCPayServer.Tests/FastTests.cs

@@ -483,93 +483,6 @@ namespace BTCPayServer.Tests
         }
 #endif
 
-        [Fact]
-        public void CanParseLegacyLabels()
-        {
-            static void AssertContainsRawLabel(WalletTransactionInfo info)
-            {
-                foreach (var item in new[] { "blah", "lol", "hello" })
-                {
-                    Assert.True(info.Labels.ContainsKey(item));
-                    var rawLabel = Assert.IsType<RawLabel>(info.Labels[item]);
-                    Assert.Equal("raw", rawLabel.Type);
-                    Assert.Equal(item, rawLabel.Text);
-                }
-            }
-            var data = new WalletTransactionData();
-            data.Labels = "blah,lol,hello,lol";
-            var info = data.GetBlobInfo();
-            Assert.Equal(3, info.Labels.Count);
-            AssertContainsRawLabel(info);
-            data.SetBlobInfo(info);
-            Assert.Contains("raw", data.Labels);
-            Assert.Contains("{", data.Labels);
-            Assert.Contains("[", data.Labels);
-            info = data.GetBlobInfo();
-            AssertContainsRawLabel(info);
-
-
-            data = new WalletTransactionData()
-            {
-                Labels = "pos",
-                Blob = Encoders.Hex.DecodeData("1f8b08000000000000037abf7b7fb592737e6e6e6a5e89929592522d000000ffff030036bc6ad911000000")
-            };
-            info = data.GetBlobInfo();
-            var label = Assert.Single(info.Labels);
-            Assert.Equal("raw", label.Value.Type);
-            Assert.Equal("pos", label.Value.Text);
-            Assert.Equal("pos", label.Key);
-
-
-            static void AssertContainsLabel(WalletTransactionInfo info)
-            {
-                Assert.Equal(2, info.Labels.Count);
-                var invoiceLabel = Assert.IsType<ReferenceLabel>(info.Labels["invoice"]);
-                Assert.Equal("BFm1MCJPBCDeRoWXvPcwnM", invoiceLabel.Reference);
-                Assert.Equal("invoice", invoiceLabel.Text);
-                Assert.Equal("invoice", invoiceLabel.Type);
-
-                var appLabel = Assert.IsType<ReferenceLabel>(info.Labels["app"]);
-                Assert.Equal("87kj5yKay8mB4UUZcJhZH5TqDKMD3CznjwLjiu1oYZXe", appLabel.Reference);
-                Assert.Equal("app", appLabel.Text);
-                Assert.Equal("app", appLabel.Type);
-            }
-            data = new WalletTransactionData()
-            {
-                Labels = "[\"{\\n  \\\"value\\\": \\\"invoice\\\",\\n  \\\"id\\\": \\\"BFm1MCJPBCDeRoWXvPcwnM\\\"\\n}\",\"{\\n  \\\"value\\\": \\\"app\\\",\\n  \\\"id\\\": \\\"87kj5yKay8mB4UUZcJhZH5TqDKMD3CznjwLjiu1oYZXe\\\"\\n}\"]",
-            };
-            info = data.GetBlobInfo();
-            AssertContainsLabel(info);
-            data.SetBlobInfo(info);
-            info = data.GetBlobInfo();
-            AssertContainsLabel(info);
-
-            static void AssertPayoutLabel(WalletTransactionInfo info)
-            {
-                Assert.Single(info.Labels);
-                var l = Assert.IsType<PayoutLabel>(info.Labels["payout"]);
-                Assert.Single(Assert.Single(l.PullPaymentPayouts, k => k.Key == "pullPaymentId").Value, "payoutId");
-                Assert.Equal("walletId", l.WalletId);
-            }
-
-            var payoutId = "payoutId";
-            var pullPaymentId = "pullPaymentId";
-            var walletId = "walletId";
-            // How it was serialized before
-
-            data = new WalletTransactionData()
-            {
-                Labels = new JArray(JObject.FromObject(new { value = "payout", id = payoutId, pullPaymentId, walletId })).ToString()
-            };
-            info = data.GetBlobInfo();
-            AssertPayoutLabel(info);
-            data.SetBlobInfo(info);
-            info = data.GetBlobInfo();
-            AssertPayoutLabel(info);
-        }
-
-
-
         [Fact]
         public void DeterministicUTXOSorter()
         {
@@ -1294,6 +1207,9 @@ namespace BTCPayServer.Tests
         [Fact]
         public void CanParseRateRules()
         {
+            var pair = CurrencyPair.Parse("USD_EMAT_IC");
+            Assert.Equal("USD", pair.Left);
+            Assert.Equal("EMAT_IC", pair.Right);
             // Check happy path
             StringBuilder builder = new StringBuilder();
             builder.AppendLine("// Some cool comments");
@@ -1389,7 +1305,7 @@ namespace BTCPayServer.Tests
             rule2.Reevaluate();
             Assert.False(rule2.HasError);
             Assert.Equal("5000 * 2000.4 * 1.1", rule2.ToString(true));
-            Assert.Equal(rule2.BidAsk.Bid, 5000m * 2000.4m * 1.1m);
+            Assert.Equal(5000m * 2000.4m * 1.1m, rule2.BidAsk.Bid);
             ////////
 
             // Make sure parenthesis are correctly calculated

BTCPayServer.Tests/GreenfieldAPITests.cs

@@ -19,6 +19,7 @@ using BTCPayServer.Services.Custodian.Client.MockCustodian;
 using BTCPayServer.Services;
 using BTCPayServer.Services.Notifications;
 using BTCPayServer.Services.Notifications.Blobs;
+using BTCPayServer.Services.Stores;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
@@ -88,7 +89,7 @@ namespace BTCPayServer.Tests
             Assert.Equal("missing-permission", e.APIError.Code);
             Assert.NotNull(e.APIError.Message);
             GreenfieldPermissionAPIError permissionError = Assert.IsType<GreenfieldPermissionAPIError>(e.APIError);
-            Assert.Equal(permissionError.MissingPermission, Policies.CanModifyStoreSettings);
+            Assert.Equal(Policies.CanModifyStoreSettings, permissionError.MissingPermission);
         }
 
         [Fact(Timeout = TestTimeout)]
@@ -287,6 +288,117 @@ namespace BTCPayServer.Tests
                 await client.GetApp(retrievedApp.Id);
             });
         }
+
+        [Fact(Timeout = TestTimeout)]
+        [Trait("Integration", "Integration")]
+        public async Task CanCreateCrowdfundApp()
+        {
+            using var tester = CreateServerTester();
+            await tester.StartAsync();
+            var user = tester.NewAccount();
+            await user.RegisterDerivationSchemeAsync("BTC");
+            var client = await user.CreateClient();
+
+            // Test validation for creating the app
+            await AssertValidationError(new[] { "AppName" },
+                async () => await client.CreateCrowdfundApp(user.StoreId, new CreateCrowdfundAppRequest() {}));
+            await AssertValidationError(new[] { "AppName" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        AppName = "this is a really long app name this is a really long app name this is a really long app name",
+                    }
+                )
+            );
+            await AssertValidationError(new[] { "TargetCurrency" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        AppName = "good name",
+                        TargetCurrency = "fake currency"
+                    }
+                )
+            );
+            await AssertValidationError(new[] { "PerksTemplate" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        AppName = "good name",
+                        PerksTemplate = "lol invalid template"
+                    }
+                )
+            );
+            await AssertValidationError(new[] { "AppName", "TargetCurrency", "PerksTemplate" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        TargetCurrency = "fake currency",
+                        PerksTemplate = "lol invalid template"
+                    }
+                )
+            );
+            await AssertValidationError(new[] { "AnimationColors" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        AppName = "good name",
+                        AnimationColors = new string[] {}
+                    }
+                )
+            );
+            await AssertValidationError(new[] { "AnimationColors" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        AppName = "good name",
+                        AnimationColors = new string[] { "  ", " " }
+                    }
+                )
+            );
+            await AssertValidationError(new[] { "Sounds" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        AppName = "good name",
+                        Sounds = new string[] { "  " }
+                    }
+                )
+            );
+            await AssertValidationError(new[] { "Sounds" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        AppName = "good name",
+                        Sounds = new string[] { " ", " ", " "  }
+                    }
+                )
+            );
+            await AssertValidationError(new[] { "EndDate" },
+                async () => await client.CreateCrowdfundApp(
+                    user.StoreId,
+                    new CreateCrowdfundAppRequest()
+                    {
+                        AppName = "good name",
+                        StartDate = DateTime.Parse("1998-01-01"),
+                        EndDate = DateTime.Parse("1997-12-31")
+                    }
+                )
+            );
+
+            // Test creating a crowdfund app
+            var app = await client.CreateCrowdfundApp(user.StoreId, new CreateCrowdfundAppRequest() { AppName = "test app from API" });
+            Assert.Equal("test app from API", app.Name);
+            Assert.Equal(user.StoreId, app.StoreId);
+            Assert.Equal("Crowdfund", app.AppType);
+        }
         
         [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
@@ -796,6 +908,100 @@ namespace BTCPayServer.Tests
             await AssertAPIError("invalid-state", async () => await client.MarkPayoutPaid(storeId, payout.Id));
         }
 
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanProcessPayoutsExternally()
+        {
+            using var tester = CreateServerTester();
+            await tester.StartAsync();
+            var acc = tester.NewAccount();
+            acc.Register();
+            await acc.CreateStoreAsync();
+            var storeId = (await acc.RegisterDerivationSchemeAsync("BTC", importKeysToNBX: true)).StoreId;
+            var client = await acc.CreateClient();
+            var address = await tester.ExplorerNode.GetNewAddressAsync();
+            var payout = await client.CreatePayout(storeId, new CreatePayoutThroughStoreRequest()
+            {
+                 Approved = false,
+                 PaymentMethod = "BTC",
+                 Amount = 0.0001m,
+                 Destination = address.ToString()
+            });
+            await AssertAPIError("invalid-state", async () =>
+            {
+                await client.MarkPayout(storeId, payout.Id, new MarkPayoutRequest() {State = PayoutState.Completed});
+
+            });
+
+            await client.ApprovePayout(storeId, payout.Id, new ApprovePayoutRequest());
+            
+            await client.MarkPayout(storeId, payout.Id, new MarkPayoutRequest() {State = PayoutState.Completed});
+            Assert.Equal(PayoutState.Completed,(await client.GetStorePayouts(storeId,false)).Single(data => data.Id == payout.Id ).State );
+            Assert.Null((await client.GetStorePayouts(storeId,false)).Single(data => data.Id == payout.Id ).PaymentProof );
+
+            foreach (var state in new []{ PayoutState.AwaitingApproval, PayoutState.Cancelled, PayoutState.Completed, PayoutState.AwaitingApproval, PayoutState.InProgress})
+            {
+                await AssertAPIError("invalid-state", async () =>
+                {
+                    await client.MarkPayout(storeId, payout.Id, new MarkPayoutRequest() {State = state});
+                });
+            }
+            payout = await client.CreatePayout(storeId, new CreatePayoutThroughStoreRequest()
+            {
+                Approved = true,
+                PaymentMethod = "BTC",
+                Amount = 0.0001m,
+                Destination = address.ToString()
+            });
+
+            payout = await client.GetStorePayout(storeId, payout.Id);
+            Assert.NotNull(payout);
+            Assert.Equal(PayoutState.AwaitingPayment, payout.State);
+            await AssertValidationError(new []{"PaymentProof"}, async () =>
+            {
+                await client.MarkPayout(storeId, payout.Id, new MarkPayoutRequest() {State = PayoutState.Completed, PaymentProof = JObject.FromObject(new
+                {
+                    test = "zyx"
+                })});
+            });
+            await client.MarkPayout(storeId, payout.Id, new MarkPayoutRequest() {State = PayoutState.InProgress, PaymentProof = JObject.FromObject(new
+            {
+                proofType = "external-proof"
+            })});
+            payout = await client.GetStorePayout(storeId, payout.Id);
+            Assert.NotNull(payout);
+            Assert.Equal(PayoutState.InProgress, payout.State);
+            Assert.True(payout.PaymentProof.TryGetValue("proofType", out var savedType));
+            Assert.Equal("external-proof",savedType);
+            
+            await client.MarkPayout(storeId, payout.Id, new MarkPayoutRequest() {State = PayoutState.AwaitingPayment, PaymentProof = JObject.FromObject(new
+            {
+                proofType = "external-proof",
+                id="finality proof",
+                link="proof.com"
+            })});
+            payout = await client.GetStorePayout(storeId, payout.Id);
+            Assert.NotNull(payout);
+            Assert.Null(payout.PaymentProof);
+            Assert.Equal(PayoutState.AwaitingPayment, payout.State);
+            
+            await client.MarkPayout(storeId, payout.Id, new MarkPayoutRequest() {State = PayoutState.Completed, PaymentProof = JObject.FromObject(new
+            {
+                proofType = "external-proof",
+                id="finality proof",
+                link="proof.com"
+            })});
+            payout = await client.GetStorePayout(storeId, payout.Id);
+            Assert.NotNull(payout);
+            Assert.Equal(PayoutState.Completed, payout.State);
+            Assert.True(payout.PaymentProof.TryGetValue("proofType", out savedType));
+            Assert.True(payout.PaymentProof.TryGetValue("link", out var savedLink));
+            Assert.True(payout.PaymentProof.TryGetValue("id", out var savedId));
+            Assert.Equal("external-proof",savedType);
+            Assert.Equal("finality proof",savedId);
+            Assert.Equal("proof.com",savedLink);
+        }
+
         private DateTimeOffset RoundSeconds(DateTimeOffset dateTimeOffset)
         {
             return new DateTimeOffset(dateTimeOffset.Year, dateTimeOffset.Month, dateTimeOffset.Day, dateTimeOffset.Hour, dateTimeOffset.Minute, dateTimeOffset.Second, dateTimeOffset.Offset);
@@ -1168,25 +1374,93 @@ namespace BTCPayServer.Tests
             await client.ArchivePaymentRequest(user.StoreId, paymentRequest.Id);
             Assert.DoesNotContain(paymentRequest.Id,
                 (await client.GetPaymentRequests(user.StoreId)).Select(data => data.Id));
-
-            //let's test some payment stuff
+            var archivedPrId = paymentRequest.Id;
+            //let's test some payment stuff with the UI
             await user.RegisterDerivationSchemeAsync("BTC");
             var paymentTestPaymentRequest = await client.CreatePaymentRequest(user.StoreId,
                 new CreatePaymentRequestRequest() { Amount = 0.1m, Currency = "BTC", Title = "Payment test title" });
 
             var invoiceId = Assert.IsType<string>(Assert.IsType<OkObjectResult>(await user.GetController<UIPaymentRequestController>()
                 .PayPaymentRequest(paymentTestPaymentRequest.Id, false)).Value);
-            var invoice = user.BitPay.GetInvoice(invoiceId);
-            await tester.WaitForEvent<InvoiceDataChangedEvent>(async () =>
+
+            async Task Pay(string invoiceId, bool partialPayment = false)
             {
-                await tester.ExplorerNode.SendToAddressAsync(
-                    BitcoinAddress.Create(invoice.BitcoinAddress, tester.ExplorerNode.Network), invoice.BtcDue);
+                TestLogs.LogInformation($"Paying invoice {invoiceId}");
+                var invoice = user.BitPay.GetInvoice(invoiceId);
+                await tester.WaitForEvent<InvoiceDataChangedEvent>(async () =>
+                {
+                    TestLogs.LogInformation($"Paying address {invoice.BitcoinAddress}");
+                    await tester.ExplorerNode.SendToAddressAsync(
+                        BitcoinAddress.Create(invoice.BitcoinAddress, tester.ExplorerNode.Network), invoice.BtcDue);
+                });
+                await TestUtils.EventuallyAsync(async () =>
+                 {
+                     Assert.Equal(Invoice.STATUS_PAID, user.BitPay.GetInvoice(invoiceId).Status);
+                     if (!partialPayment)
+                        Assert.Equal(PaymentRequestData.PaymentRequestStatus.Completed, (await client.GetPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id)).Status);
+                 });
+            }
+            await Pay(invoiceId);
+
+            //Same thing, but with the API
+            paymentTestPaymentRequest = await client.CreatePaymentRequest(user.StoreId,
+                new CreatePaymentRequestRequest() { Amount = 0.1m, Currency = "BTC", Title = "Payment test title" });
+            var paidPrId = paymentTestPaymentRequest.Id;
+            var invoiceData = await client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest());
+            await Pay(invoiceData.Id);
+
+            // Let's tests some unhappy path
+            paymentTestPaymentRequest = await client.CreatePaymentRequest(user.StoreId,
+                new CreatePaymentRequestRequest() { Amount = 0.1m, AllowCustomPaymentAmounts = false, Currency = "BTC", Title = "Payment test title" });
+            await AssertValidationError(new[] { "Amount" }, () => client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest() { Amount = -0.04m }));
+            await AssertValidationError(new[] { "Amount" }, () => client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest() { Amount = 0.04m }));
+            await client.UpdatePaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new UpdatePaymentRequestRequest()
+            {
+                Amount = 0.1m,
+                AllowCustomPaymentAmounts = true,
+                Currency = "BTC",
+                Title = "Payment test title"
             });
-            await TestUtils.EventuallyAsync(async () =>
-             {
-                 Assert.Equal(Invoice.STATUS_PAID, user.BitPay.GetInvoice(invoiceId).Status);
-                 Assert.Equal(PaymentRequestData.PaymentRequestStatus.Completed, (await client.GetPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id)).Status);
-             });
+            await AssertValidationError(new[] { "Amount" }, () => client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest() { Amount = -0.04m }));
+            invoiceData = await client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest() { Amount = 0.04m });
+            Assert.Equal(0.04m, invoiceData.Amount);
+            var firstPaymentId = invoiceData.Id;
+            await AssertAPIError("archived", () => client.PayPaymentRequest(user.StoreId, archivedPrId, new PayPaymentRequestRequest()));
+
+            await client.UpdatePaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new UpdatePaymentRequestRequest()
+            {
+                Amount = 0.1m,
+                AllowCustomPaymentAmounts = true,
+                Currency = "BTC",
+                Title = "Payment test title",
+                ExpiryDate = DateTimeOffset.UtcNow - TimeSpan.FromDays(1.0)
+            });
+
+            await AssertAPIError("expired", () => client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest()));
+            await AssertAPIError("already-paid", () => client.PayPaymentRequest(user.StoreId, paidPrId, new PayPaymentRequestRequest()));
+
+            await client.UpdatePaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new UpdatePaymentRequestRequest()
+            {
+                Amount = 0.1m,
+                AllowCustomPaymentAmounts = true,
+                Currency = "BTC",
+                Title = "Payment test title",
+                ExpiryDate = null
+            });
+
+            await Pay(firstPaymentId, true);
+            invoiceData = await client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest());
+
+            Assert.Equal(0.06m, invoiceData.Amount);
+            Assert.Equal("BTC", invoiceData.Currency);
+
+            var expectedInvoiceId = invoiceData.Id;
+            invoiceData = await client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest() { AllowPendingInvoiceReuse = true });
+            Assert.Equal(expectedInvoiceId, invoiceData.Id);
+
+            var notExpectedInvoiceId = invoiceData.Id;
+            invoiceData = await client.PayPaymentRequest(user.StoreId, paymentTestPaymentRequest.Id, new PayPaymentRequestRequest() { AllowPendingInvoiceReuse = false });
+            Assert.NotEqual(notExpectedInvoiceId, invoiceData.Id);
         }
 
         [Fact(Timeout = TestTimeout)]
@@ -1324,7 +1598,7 @@ namespace BTCPayServer.Tests
                     Checkout = new CreateInvoiceRequest.CheckoutOptions()
                     {
                         RedirectAutomatically = true,
-                        RequiresRefundEmail = true
+                        RequiresRefundEmail = true,
                     },
                     AdditionalSearchTerms = new string[] { "Banana" }
                 });
@@ -1653,25 +1927,35 @@ namespace BTCPayServer.Tests
             await tester.StartAsync();
             await tester.EnsureChannelsSetup();
             var user = tester.NewAccount();
-            user.GrantAccess(true);
+            await user.GrantAccessAsync(true);
             user.RegisterLightningNode("BTC", LightningConnectionType.CLightning, false);
 
             var merchant = tester.NewAccount();
-            merchant.GrantAccess(true);
+            await merchant.GrantAccessAsync(true);
             merchant.RegisterLightningNode("BTC", LightningConnectionType.LndREST);
             var merchantClient = await merchant.CreateClient($"{Policies.CanUseLightningNodeInStore}:{merchant.StoreId}");
             var merchantInvoice = await merchantClient.CreateLightningInvoice(merchant.StoreId, "BTC", new CreateLightningInvoiceRequest(LightMoney.Satoshis(1_000), "hey", TimeSpan.FromSeconds(60)));
             // The default client is using charge, so we should not be able to query channels
-            var client = await user.CreateClient(Policies.CanUseInternalLightningNode);
+            var chargeClient = await user.CreateClient(Policies.CanUseInternalLightningNode);
 
-            var info = await client.GetLightningNodeInfo("BTC");
+            var info = await chargeClient.GetLightningNodeInfo("BTC");
             Assert.Single(info.NodeURIs);
             Assert.NotEqual(0, info.BlockHeight);
+            Assert.NotNull(info.Alias);
+            Assert.NotNull(info.Color);
+            Assert.NotNull(info.Version);
+            Assert.NotNull(info.PeersCount);
+            Assert.NotNull(info.ActiveChannelsCount);
+            Assert.NotNull(info.InactiveChannelsCount);
+            Assert.NotNull(info.PendingChannelsCount);
 
-            await AssertAPIError("lightning-node-unavailable", () => client.GetLightningNodeChannels("BTC"));
+            var gex = await AssertAPIError("lightning-node-unavailable", () => chargeClient.ConnectToLightningNode("BTC", new ConnectToNodeRequest(NodeInfo.Parse($"{new Key().PubKey.ToHex()}@localhost:3827"))));
+            Assert.Contains("NotSupported", gex.Message);
+
+            await AssertAPIError("lightning-node-unavailable", () => chargeClient.GetLightningNodeChannels("BTC"));
             // Not permission for the store!
-            await AssertAPIError("missing-permission", () => client.GetLightningNodeChannels(user.StoreId, "BTC"));
-            var invoiceData = await client.CreateLightningInvoice("BTC", new CreateLightningInvoiceRequest()
+            await AssertAPIError("missing-permission", () => chargeClient.GetLightningNodeChannels(user.StoreId, "BTC"));
+            var invoiceData = await chargeClient.CreateLightningInvoice("BTC", new CreateLightningInvoiceRequest()
             {
                 Amount = LightMoney.Satoshis(1000),
                 Description = "lol",
@@ -1679,9 +1963,17 @@ namespace BTCPayServer.Tests
                 PrivateRouteHints = false
             });
             var chargeInvoice = invoiceData;
-            Assert.NotNull(await client.GetLightningInvoice("BTC", invoiceData.Id));
+            Assert.NotNull(await chargeClient.GetLightningInvoice("BTC", invoiceData.Id));
 
-            client = await user.CreateClient($"{Policies.CanUseLightningNodeInStore}:{user.StoreId}");
+            // check list for internal node
+            var invoices = await chargeClient.GetLightningInvoices("BTC");
+            var pendingInvoices = await chargeClient.GetLightningInvoices("BTC", true);
+            Assert.NotEmpty(invoices);
+            Assert.Contains(invoices, i => i.Id == invoiceData.Id);
+            Assert.NotEmpty(pendingInvoices);
+            Assert.Contains(pendingInvoices, i => i.Id == invoiceData.Id);
+
+            var client = await user.CreateClient($"{Policies.CanUseLightningNodeInStore}:{user.StoreId}");
             // Not permission for the server
             await AssertAPIError("missing-permission", () => client.GetLightningNodeChannels("BTC"));
 
@@ -1699,10 +1991,22 @@ namespace BTCPayServer.Tests
 
             Assert.NotNull(await client.GetLightningInvoice(user.StoreId, "BTC", invoiceData.Id));
 
-            await client.PayLightningInvoice(user.StoreId, "BTC", new PayLightningInvoiceRequest()
+            // check pending list
+            var merchantPendingInvoices = await merchantClient.GetLightningInvoices(merchant.StoreId, "BTC", true);
+            Assert.NotEmpty(merchantPendingInvoices);
+            Assert.Contains(merchantPendingInvoices, i => i.Id == merchantInvoice.Id);
+            
+            var payResponse = await client.PayLightningInvoice(user.StoreId, "BTC", new PayLightningInvoiceRequest
             {
                 BOLT11 = merchantInvoice.BOLT11
             });
+            Assert.Equal(merchantInvoice.BOLT11, payResponse.BOLT11);
+            Assert.Equal(LightningPaymentStatus.Complete, payResponse.Status);
+            Assert.NotNull(payResponse.Preimage);
+            Assert.NotNull(payResponse.FeeAmount);
+            Assert.NotNull(payResponse.TotalAmount);
+            Assert.NotNull(payResponse.PaymentHash);
+            
             await Assert.ThrowsAsync<GreenfieldValidationException>(async () => await client.PayLightningInvoice(user.StoreId, "BTC", new PayLightningInvoiceRequest()
             {
                 BOLT11 = "lol"
@@ -1719,6 +2023,15 @@ namespace BTCPayServer.Tests
             var invoice = await merchantClient.GetLightningInvoice(merchant.StoreId, "BTC", merchantInvoice.Id);
             Assert.NotNull(invoice.PaidAt);
             Assert.Equal(LightMoney.Satoshis(1000), invoice.Amount);
+            
+            // check list for store with paid invoice
+            var merchantInvoices = await merchantClient.GetLightningInvoices(merchant.StoreId, "BTC");
+            merchantPendingInvoices = await merchantClient.GetLightningInvoices(merchant.StoreId, "BTC", true);
+            Assert.NotEmpty(merchantInvoices);
+            Assert.Empty(merchantPendingInvoices);
+            // if the test ran too many times the invoice might be on a later page
+            if (merchantInvoices.Length < 100) Assert.Contains(merchantInvoices, i => i.Id == merchantInvoice.Id);
+            
             // Amount received might be bigger because of internal implementation shit from lightning
             Assert.True(LightMoney.Satoshis(1000) <= invoice.AmountReceived);
 
@@ -1726,7 +2039,6 @@ namespace BTCPayServer.Tests
             Assert.Single(info.NodeURIs);
             Assert.NotEqual(0, info.BlockHeight);
 
-
             // As admin, can use the internal node through our store.
             await user.MakeAdmin(true);
             await user.RegisterInternalLightningNodeAsync("BTC");
@@ -1736,7 +2048,7 @@ namespace BTCPayServer.Tests
             await AssertPermissionError("btcpay.server.canuseinternallightningnode", () => client.GetLightningNodeInfo(user.StoreId, "BTC"));
             // However, even as a guest, you should be able to create an invoice
             var guest = tester.NewAccount();
-            guest.GrantAccess(false);
+            await guest.GrantAccessAsync();
             await user.AddGuest(guest.UserId);
             client = await guest.CreateClient(Policies.CanCreateLightningInvoiceInStore);
             await client.CreateLightningInvoice(user.StoreId, "BTC", new CreateLightningInvoiceRequest()
@@ -2263,6 +2575,7 @@ namespace BTCPayServer.Tests
 
             Assert.Equal(transaction.TransactionHash, txdata.TransactionHash);
             Assert.Equal(String.Empty, transaction.Comment);
+#pragma warning disable CS0612 // Type or member is obsolete
             Assert.Equal(new Dictionary<string, LabelData>(), transaction.Labels);
 
             // transaction patch tests
@@ -2283,7 +2596,7 @@ namespace BTCPayServer.Tests
                 }.ToJson(),
                 patchedTransaction.Labels.ToJson()
             );
-
+#pragma warning restore CS0612 // Type or member is obsolete
             await AssertHttpError(403, async () =>
             {
                 await viewOnlyClient.ShowOnChainWalletTransactions(walletId.StoreId, walletId.CryptoCode);
@@ -2674,7 +2987,134 @@ namespace BTCPayServer.Tests
              Assert.Empty(payouts.Where(data => data.State != PayoutState.InProgress));
          });
         }
-        
+
+        [Fact(Timeout = 60 * 2 * 1000)]
+        [Trait("Integration", "Integration")]
+        public async Task CanUseWalletObjectsAPI()
+        {
+            using var tester = CreateServerTester();
+            await tester.StartAsync();
+
+            var admin = tester.NewAccount();
+            await admin.GrantAccessAsync(true);
+
+            var client = await admin.CreateClient(Policies.Unrestricted);
+
+            Assert.Empty(await client.GetOnChainWalletObjects(admin.StoreId, "BTC"));
+            var test = new OnChainWalletObjectId("test", "test");
+            Assert.NotNull(await client.AddOrUpdateOnChainWalletObject(admin.StoreId, "BTC", new AddOnChainWalletObjectRequest(test.Type, test.Id)));
+
+            Assert.Single(await client.GetOnChainWalletObjects(admin.StoreId, "BTC"));
+            Assert.NotNull(await client.GetOnChainWalletObject(admin.StoreId, "BTC", test));
+            Assert.Null(await client.GetOnChainWalletObject(admin.StoreId, "BTC", new OnChainWalletObjectId("test-wrong", "test")));
+            Assert.Null(await client.GetOnChainWalletObject(admin.StoreId, "BTC", new OnChainWalletObjectId("test", "test-wrong")));
+
+            await client.RemoveOnChainWalletObject(admin.StoreId, "BTC", new OnChainWalletObjectId("test", "test"));
+
+            Assert.Empty(await client.GetOnChainWalletObjects(admin.StoreId, "BTC"));
+
+            var test1 = new OnChainWalletObjectId("test", "test1");
+            var test2 = new OnChainWalletObjectId("test", "test2");
+            await client.AddOrUpdateOnChainWalletObject(admin.StoreId, "BTC", new AddOnChainWalletObjectRequest(test.Type, test.Id));
+            // Those links don't exists
+            await AssertAPIError("wallet-object-not-found", () => client.AddOrUpdateOnChainWalletLink(admin.StoreId, "BTC", test, new AddOnChainWalletObjectLinkRequest(test1.Type, test1.Id)));
+            await AssertAPIError("wallet-object-not-found", () => client.AddOrUpdateOnChainWalletLink(admin.StoreId, "BTC", test, new AddOnChainWalletObjectLinkRequest(test2.Type, test2.Id)));
+
+            Assert.Single(await client.GetOnChainWalletObjects(admin.StoreId, "BTC"));
+
+            await client.AddOrUpdateOnChainWalletObject(admin.StoreId, "BTC", new AddOnChainWalletObjectRequest(test1.Type, test1.Id));
+            await client.AddOrUpdateOnChainWalletObject(admin.StoreId, "BTC", new AddOnChainWalletObjectRequest(test2.Type, test2.Id));
+
+            await client.AddOrUpdateOnChainWalletLink(admin.StoreId, "BTC", test, new AddOnChainWalletObjectLinkRequest(test1.Type, test1.Id));
+            await client.AddOrUpdateOnChainWalletLink(admin.StoreId, "BTC", test, new AddOnChainWalletObjectLinkRequest(test2.Type, test2.Id));
+
+            var objs = await client.GetOnChainWalletObjects(admin.StoreId, "BTC");
+            Assert.Equal(3, objs.Length);
+            var middleObj = objs.Single(data => data.Id == "test" && data.Type == "test");
+            Assert.Equal(2, middleObj.Links.Length);
+            Assert.Contains("test1", middleObj.Links.Select(l => l.Id));
+            Assert.Contains("test2", middleObj.Links.Select(l => l.Id));
+
+            var test1Obj = objs.Single(data => data.Id == "test1" && data.Type == "test");
+            var test2Obj = objs.Single(data => data.Id == "test2" && data.Type == "test");
+            Assert.Single(test1Obj.Links.Select(l => l.Id), l => l == "test");
+            Assert.Single(test2Obj.Links.Select(l => l.Id), l => l == "test");
+
+            await client.RemoveOnChainWalletLinks(admin.StoreId, "BTC",
+                test1,
+                test);
+
+            var testObj = await client.GetOnChainWalletObject(admin.StoreId, "BTC", test);
+            Assert.Single(testObj.Links.Select(l => l.Id), l => l == "test2");
+            Assert.Single(testObj.Links);
+            test1Obj = await client.GetOnChainWalletObject(admin.StoreId, "BTC", test1);
+            Assert.Empty(test1Obj.Links);
+
+            await client.AddOrUpdateOnChainWalletLink(admin.StoreId, "BTC",
+                test1,
+                new AddOnChainWalletObjectLinkRequest(test.Type, test.Id) { Data = new JObject() { ["testData"] = "lol" } });
+
+            // Add some data to test1
+            await client.AddOrUpdateOnChainWalletObject(admin.StoreId, "BTC", new AddOnChainWalletObjectRequest() { Type = test1.Type, Id = test1.Id, Data = new JObject() { ["testData"] = "test1" } });
+
+            // Create a new type
+            await client.AddOrUpdateOnChainWalletObject(admin.StoreId, "BTC", new AddOnChainWalletObjectRequest() { Type = "newtype", Id = test1.Id });
+
+            testObj = await client.GetOnChainWalletObject(admin.StoreId, "BTC", test);
+            Assert.Single(testObj.Links.Where(l => l.Id == "test1" && l.LinkData["testData"]?.Value<string>() == "lol"));
+            Assert.Single(testObj.Links.Where(l => l.Id == "test1" && l.ObjectData["testData"]?.Value<string>() == "test1"));
+            testObj = await client.GetOnChainWalletObject(admin.StoreId, "BTC", test, false);
+            Assert.Single(testObj.Links.Where(l => l.Id == "test1" && l.LinkData["testData"]?.Value<string>() == "lol"));
+            Assert.Single(testObj.Links.Where(l => l.Id == "test1" && l.ObjectData is null));
+
+            async Task TestWalletRepository(bool useInefficient)
+            {
+                // We should have 4 nodes, two `test` type and one `newtype`
+                // Only the node `test` `test` is connected to `test1`
+                var wid = new WalletId(admin.StoreId, "BTC");
+                var repo = tester.PayTester.GetService<WalletRepository>();
+                var allObjects = await repo.GetWalletObjects((new(wid, null) { UseInefficientPath = useInefficient }));
+                var allObjectsNoWallet = await repo.GetWalletObjects((new() { UseInefficientPath = useInefficient }));
+                var allObjectsNoWalletAndType = await repo.GetWalletObjects((new() { Type = "test", UseInefficientPath = useInefficient }));
+                var allTests = await repo.GetWalletObjects((new(wid, "test") { UseInefficientPath = useInefficient }));
+                var twoTests2 = await repo.GetWalletObjects((new(wid, "test", new[] { "test1", "test2", "test-unk" }) { UseInefficientPath = useInefficient }));
+                var oneTest = await repo.GetWalletObjects((new(wid, "test", new[] { "test" }) { UseInefficientPath = useInefficient }));
+                var oneTestWithoutData = await repo.GetWalletObjects((new(wid, "test", new[] { "test" }) { UseInefficientPath = useInefficient, IncludeNeighbours = false }));
+                var idsTypes = await repo.GetWalletObjects((new(wid) { TypesIds = new[] { new ObjectTypeId("test", "test1"), new ObjectTypeId("test", "test2") }, UseInefficientPath = useInefficient }));
+
+                Assert.Equal(4, allObjects.Count);
+                // We are reusing a db in this test, as such we may have other wallets here.
+                Assert.True(allObjectsNoWallet.Count >= 4);
+                Assert.True(allObjectsNoWalletAndType.Count >= 3);
+                Assert.Equal(3, allTests.Count);
+                Assert.Equal(2, twoTests2.Count);
+                Assert.Single(oneTest);
+                Assert.NotNull(oneTest.First().Value.GetNeighbours().Select(n => n.Data).FirstOrDefault());
+                Assert.Single(oneTestWithoutData);
+                Assert.Null(oneTestWithoutData.First().Value.GetNeighbours().Select(n => n.Data).FirstOrDefault());
+                Assert.Equal(2, idsTypes.Count);
+            }
+            await TestWalletRepository(false);
+            await TestWalletRepository(true);
+
+            {
+                var allObjects = await client.GetOnChainWalletObjects(admin.StoreId, "BTC");
+                var allTests = await client.GetOnChainWalletObjects(admin.StoreId, "BTC", new GetWalletObjectsRequest() { Type = "test" });
+                var twoTests2 = await client.GetOnChainWalletObjects(admin.StoreId, "BTC", new GetWalletObjectsRequest() { Type = "test", Ids = new[] { "test1", "test2", "test-unk" } });
+                var oneTest = await client.GetOnChainWalletObjects(admin.StoreId, "BTC", new GetWalletObjectsRequest() { Type = "test", Ids=new[] { "test" } });
+                var oneTestWithoutData = await client.GetOnChainWalletObjects(admin.StoreId, "BTC", new GetWalletObjectsRequest() { Type = "test", Ids = new[] { "test" }, IncludeNeighbourData = false });
+
+                Assert.Equal(4, allObjects.Length);
+                Assert.Equal(3, allTests.Length);
+                Assert.Equal(2, twoTests2.Length);
+                Assert.Single(oneTest);
+                Assert.NotNull(oneTest.First().Links.Select(n => n.ObjectData).FirstOrDefault());
+                Assert.Single(oneTestWithoutData);
+                Assert.Null(oneTestWithoutData.First().Links.Select(n => n.ObjectData).FirstOrDefault());
+            }
+
+
+        }
         
         [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
@@ -2693,8 +3133,67 @@ namespace BTCPayServer.Tests
             Assert.NotNull(custodians);
             Assert.NotEmpty(custodians);
         }
+        
+        [Fact(Timeout = TestTimeout)]
+        [Trait("Integration", "Integration")]
+        public async Task StoreRateConfigTests()
+        {
+            using var tester = CreateServerTester();
+            await tester.StartAsync();
+            var unauthClient = new BTCPayServerClient(tester.PayTester.ServerUri);
+            await AssertHttpError(401, async () => await unauthClient.GetRateSources());
 
+            var user = tester.NewAccount();
+            await user.GrantAccessAsync();
+            var clientBasic = await user.CreateClient();
+            Assert.NotEmpty(await clientBasic.GetRateSources());
+            var config = await clientBasic.GetStoreRateConfiguration(user.StoreId);
+            Assert.NotNull(config);
+            Assert.False(config.IsCustomScript);
+            Assert.Equal("X_X = coingecko(X_X);", config.EffectiveScript);
+            Assert.Equal("coingecko", config.PreferredSource);
 
+            Assert.Equal(0.9m,
+                Assert.Single(await clientBasic.PreviewUpdateStoreRateConfiguration(user.StoreId,
+                    new StoreRateConfiguration() {IsCustomScript = true, EffectiveScript = "BTC_XYZ = 1;", Spread = 10m,},
+                    new[] {"BTC_XYZ"})).Rate);
+
+            Assert.True((await clientBasic.UpdateStoreRateConfiguration(user.StoreId,
+                    new StoreRateConfiguration() { IsCustomScript = true, EffectiveScript = "BTC_XYZ = 1", Spread = 10m,}))
+                .IsCustomScript);
+            
+            config = await clientBasic.GetStoreRateConfiguration(user.StoreId);
+            Assert.NotNull(config);
+            Assert.NotNull(config.EffectiveScript);
+            Assert.Equal("BTC_XYZ = 1;", config.EffectiveScript);
+            Assert.Equal(10m, config.Spread);
+            Assert.Null(config.PreferredSource);
+
+            Assert.NotNull((await clientBasic.GetStoreRateConfiguration(user.StoreId)).EffectiveScript);
+            Assert.NotNull((await clientBasic.UpdateStoreRateConfiguration(user.StoreId,
+                    new StoreRateConfiguration() { IsCustomScript = false, PreferredSource = "coingecko"}))
+                .PreferredSource);
+
+            config = await clientBasic.GetStoreRateConfiguration(user.StoreId);
+            Assert.Equal("X_X = coingecko(X_X);", config.EffectiveScript);
+
+            await AssertValidationError(new[] { "EffectiveScript", "PreferredSource" }, () =>
+            clientBasic.UpdateStoreRateConfiguration(user.StoreId, new StoreRateConfiguration() { IsCustomScript = false, EffectiveScript = "BTC_XYZ = 1;" }));
+
+            await AssertValidationError(new[] { "EffectiveScript" }, () =>
+clientBasic.UpdateStoreRateConfiguration(user.StoreId, new StoreRateConfiguration() { IsCustomScript = true, EffectiveScript = "BTC_XYZ rg8w*# 1;" }));
+            await AssertValidationError(new[] { "PreferredSource" }, () =>
+clientBasic.UpdateStoreRateConfiguration(user.StoreId, new StoreRateConfiguration() { IsCustomScript = true, EffectiveScript = "", PreferredSource = "coingecko" }));
+
+            await AssertValidationError(new[] { "PreferredSource", "Spread" }, () =>
+clientBasic.UpdateStoreRateConfiguration(user.StoreId, new StoreRateConfiguration() { IsCustomScript = false, PreferredSource = "coingeckoOOO", Spread = -1m }));
+
+            await AssertValidationError(new[] { "currencyPair" }, () =>
+clientBasic.PreviewUpdateStoreRateConfiguration(user.StoreId, new StoreRateConfiguration() { IsCustomScript = false, PreferredSource = "coingecko" }, new[] { "BTC_USD_USD_BTC" }));
+            await AssertValidationError(new[] { "PreferredSource", "currencyPair" }, () =>
+clientBasic.PreviewUpdateStoreRateConfiguration(user.StoreId, new StoreRateConfiguration() { IsCustomScript = false, PreferredSource = "coingeckoOOO" }, new[] { "BTC_USD_USD_BTC" }));
+        }
+        
         [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CustodianAccountControllerTests()

BTCPayServer.Tests/SeleniumTester.cs

@@ -185,6 +185,15 @@ namespace BTCPayServer.Tests
             return (name, storeId);
         }
 
+        public void EnableCheckoutV2(bool bip21 = false)
+        {
+            GoToStore(StoreNavPages.CheckoutAppearance);
+            Driver.SetCheckbox(By.Id("UseNewCheckout"), true);
+            Driver.WaitForElement(By.Id("OnChainWithLnInvoiceFallback"));
+            Driver.SetCheckbox(By.Id("OnChainWithLnInvoiceFallback"), bip21);
+            Driver.FindElement(By.Id("Save")).Click();
+        }
+
         public Mnemonic GenerateWallet(string cryptoCode = "BTC", string seed = "", bool? importkeys = null, bool isHotWallet = false, ScriptPubKeyType format = ScriptPubKeyType.Segwit)
         {
             var isImport = !string.IsNullOrEmpty(seed);

BTCPayServer.Tests/SeleniumTests.cs

@@ -64,6 +64,61 @@ namespace BTCPayServer.Tests
             s.Driver.Quit();
         }
         
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanUseForms()
+        {
+            using var s = CreateSeleniumTester();
+            await s.StartAsync();
+            s.RegisterNewUser(true);
+            s.CreateNewStore();
+            s.GenerateWallet(isHotWallet: true);
+            
+            // Point Of Sale
+            s.Driver.FindElement(By.Id("StoreNav-CreateApp")).Click();
+            new SelectElement(s.Driver.FindElement(By.Id("SelectedAppType"))).SelectByValue("PointOfSale");
+            s.Driver.FindElement(By.Id("AppName")).SendKeys(Guid.NewGuid().ToString());
+            s.Driver.FindElement(By.Id("Create")).Click();
+            Assert.Contains("App successfully created", s.FindAlertMessage().Text);
+            
+            new SelectElement(s.Driver.FindElement(By.Id("FormId"))).SelectByValue("Email");
+            s.Driver.FindElement(By.Id("SaveSettings")).Click();
+            Assert.Contains("App updated", s.FindAlertMessage().Text);
+
+            s.Driver.FindElement(By.Id("ViewApp")).Click();
+            var windows = s.Driver.WindowHandles;
+            Assert.Equal(2, windows.Count);
+            s.Driver.SwitchTo().Window(windows[1]);
+            s.Driver.FindElement(By.CssSelector("button[type='submit']")).Click();
+            
+            Assert.Contains("Enter your email", s.Driver.PageSource);
+            s.Driver.FindElement(By.Name("buyerEmail")).SendKeys("aa@aa.com");
+            s.Driver.FindElement(By.CssSelector("input[type='submit']")).Click();
+            
+            s.PayInvoice(true);
+            var invoiceId = s.Driver.Url[(s.Driver.Url.LastIndexOf("/", StringComparison.Ordinal) + 1)..];
+            s.GoToInvoice(invoiceId);
+            Assert.Contains("aa@aa.com", s.Driver.PageSource);
+            
+            // Payment Request
+            s.Driver.FindElement(By.Id("StoreNav-PaymentRequests")).Click();
+            s.Driver.FindElement(By.Id("CreatePaymentRequest")).Click();
+            s.Driver.FindElement(By.Id("Title")).SendKeys("Pay123");
+            s.Driver.FindElement(By.Id("Amount")).SendKeys("700");
+            new SelectElement(s.Driver.FindElement(By.Id("FormId"))).SelectByValue("Email");
+            s.Driver.FindElement(By.Id("SaveButton")).Click();
+            
+            s.Driver.FindElement(By.XPath("//a[starts-with(@id, 'Edit-')]")).Click();
+            var editUrl = s.Driver.Url;
+            s.Driver.FindElement(By.Id("ViewPaymentRequest")).Click();
+            s.Driver.FindElement(By.CssSelector("[data-test='form-button']")).Click();
+            Assert.Contains("Enter your email", s.Driver.PageSource);
+            
+            s.Driver.FindElement(By.Name("buyerEmail")).SendKeys("aa@aa.com");
+            s.Driver.FindElement(By.CssSelector("input[type='submit']")).Click();
+            s.Driver.Navigate().GoToUrl(editUrl);
+            Assert.Contains("aa@aa.com", s.Driver.PageSource);
+        }
+        
         [Fact(Timeout = TestTimeout)]
         public async Task CanUseCPFP()
         {
@@ -644,15 +699,26 @@ namespace BTCPayServer.Tests
             s.Driver.FindElement(By.Id("enable-pay-button")).Click();
             s.Driver.FindElement(By.Id("disable-pay-button")).Click();
             s.FindAlertMessage();
-            s.GoToStore(StoreNavPages.General);
+            s.GoToStore();
             Assert.False(s.Driver.FindElement(By.Id("AnyoneCanCreateInvoice")).Selected);
             s.Driver.SetCheckbox(By.Id("AnyoneCanCreateInvoice"), true);
             s.Driver.FindElement(By.Id("Save")).Click();
             s.FindAlertMessage();
             Assert.True(s.Driver.FindElement(By.Id("AnyoneCanCreateInvoice")).Selected);
 
+            // Store settings: Set and unset brand color
+            s.GoToStore();
+            s.Driver.FindElement(By.Id("BrandColor")).SendKeys("#f7931a");
+            s.Driver.FindElement(By.Id("Save")).Click();
+            Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
+            Assert.Equal("#f7931a", s.Driver.FindElement(By.Id("BrandColor")).GetAttribute("value"));
+            s.Driver.FindElement(By.Id("BrandColor")).Clear();
+            s.Driver.FindElement(By.Id("Save")).Click();
+            Assert.Contains("Store successfully updated", s.FindAlertMessage().Text);
+            Assert.Equal(string.Empty, s.Driver.FindElement(By.Id("BrandColor")).GetAttribute("value"));
+
             // Alice should be able to delete the store
-            s.GoToStore(StoreNavPages.General);
+            s.GoToStore();
             s.Driver.FindElement(By.Id("DeleteStore")).Click();
             s.Driver.WaitForElement(By.Id("ConfirmInput")).SendKeys("DELETE");
             s.Driver.FindElement(By.Id("ConfirmContinue")).Click();
@@ -860,9 +926,8 @@ namespace BTCPayServer.Tests
             var viewUrl = s.Driver.Url;
             
             Assert.Equal("Amount due", s.Driver.FindElement(By.CssSelector("[data-test='amount-due-title']")).Text);
-            Assert.Equal("Pay Invoice",
-                s.Driver.FindElement(By.CssSelector("[data-test='pay-button']")).Text.Trim());
-
+            Assert.Equal("Pay Invoice", s.Driver.FindElement(By.CssSelector("[data-test='pay-button']")).Text.Trim());
+            
             // expire
             s.GoToUrl(editUrl);
             s.Driver.ExecuteJavaScript("document.getElementById('ExpiryDate').value = '2021-01-21T21:00:00.000Z'");
@@ -880,8 +945,13 @@ namespace BTCPayServer.Tests
             
             s.GoToUrl(viewUrl);
             s.Driver.AssertElementNotFound(By.CssSelector("[data-test='status']"));
-            Assert.Equal("Pay Invoice",
-                s.Driver.FindElement(By.CssSelector("[data-test='pay-button']")).Text.Trim());
+            Assert.Equal("Pay Invoice", s.Driver.FindElement(By.CssSelector("[data-test='pay-button']")).Text.Trim());
+            
+            // test invoice creation, click with JS, because the button is inside a sticky header
+            s.Driver.ExecuteJavaScript("document.querySelector('[data-test=\"pay-button\"]').click()");
+            // checkout v1
+            s.Driver.WaitForElement(By.CssSelector("invoice"));
+            Assert.Contains("Awaiting Payment", s.Driver.PageSource);
             
             // archive (from details page)
             s.GoToUrl(editUrl);
@@ -1010,10 +1080,10 @@ namespace BTCPayServer.Tests
             }
 
             // This one should be checked
-            Assert.Contains($"value=\"InvoiceProcessing\" checked", s.Driver.PageSource);
-            Assert.Contains($"value=\"InvoiceCreated\" checked", s.Driver.PageSource);
+            Assert.Contains("value=\"InvoiceProcessing\" checked", s.Driver.PageSource);
+            Assert.Contains("value=\"InvoiceCreated\" checked", s.Driver.PageSource);
             // This one never been checked
-            Assert.DoesNotContain($"value=\"InvoiceReceivedPayment\" checked", s.Driver.PageSource);
+            Assert.DoesNotContain("value=\"InvoiceReceivedPayment\" checked", s.Driver.PageSource);
 
             s.Driver.FindElement(By.Name("update")).Click();
             s.FindAlertMessage();
@@ -1044,6 +1114,7 @@ namespace BTCPayServer.Tests
             s.GoToStore(StoreNavPages.Webhooks);
             s.Driver.FindElement(By.LinkText("Modify")).Click();
             var elements = s.Driver.FindElements(By.ClassName("redeliver"));
+            
             // One worked, one failed
             s.Driver.FindElement(By.ClassName("fa-times"));
             s.Driver.FindElement(By.ClassName("fa-check"));

BTCPayServer.Tests/ThirdPartyTests.cs

@@ -75,11 +75,11 @@ namespace BTCPayServer.Tests
         public async Task CanQueryDirectProviders()
         {
             // TODO: Check once in a while whether or not they are working again
-            string[] brokenShitcoinCasinos = { };
+            string[] brokenShitcoinCasinos = {};
+            var skipped = 0;
             var factory = FastTests.CreateBTCPayRateFactory();
             var directlySupported = factory.GetSupportedExchanges().Where(s => s.Source == RateSource.Direct)
                 .Select(s => s.Id).ToHashSet();
-            var all = string.Join("\r\n", factory.GetSupportedExchanges().Select(e => e.Id).ToArray());
             foreach (var result in factory
                 .Providers
                 .Where(p => p.Value is BackgroundFetcherRateProvider bf &&
@@ -91,14 +91,26 @@ namespace BTCPayServer.Tests
                 var name = result.ExpectedName;
                 if (brokenShitcoinCasinos.Contains(name))
                 {
-                    TestLogs.LogInformation($"Skipping {name}");
+                    TestLogs.LogInformation($"Skipping {name}: Broken shitcoin casino");
+                    skipped++;
                     continue;
                 }
                 
                 TestLogs.LogInformation($"Testing {name}");
 
                 result.Fetcher.InvalidateCache();
-                var exchangeRates = new ExchangeRates(name, result.ResultAsync.Result);
+
+                ExchangeRates exchangeRates = null;
+                try
+                {
+                    exchangeRates = new ExchangeRates(name, result.ResultAsync.Result);
+                }
+                catch (Exception exception)
+                {
+                    TestLogs.LogInformation($"Skipping {name}: {exception.Message}");
+                    skipped++;
+                    continue;
+                }
                 result.Fetcher.InvalidateCache();
                 Assert.NotNull(exchangeRates);
                 Assert.NotEmpty(exchangeRates);
@@ -160,11 +172,12 @@ namespace BTCPayServer.Tests
             // Kraken emit one request only after first GetRates
             factory.Providers["kraken"].GetRatesAsync(default).GetAwaiter().GetResult();
 
-
             var p = new KrakenExchangeRateProvider();
             var rates = await p.GetRatesAsync(default);
             Assert.Contains(rates, e => e.CurrencyPair == new CurrencyPair("XMR", "BTC") && e.BidAsk.Bid < 1.0m);
             
+            // Check we didn't skip too many exchanges
+            Assert.InRange(skipped, 0, 3);
         }
 
         [Fact]
@@ -298,17 +311,39 @@ namespace BTCPayServer.Tests
         {
             // This test verify that no malicious js is added in the minified files.
             // We should extend the tests to other js files, but we can do as we go...
-
-            using HttpClient client = new HttpClient();
-            var actual = GetFileContent("BTCPayServer", "wwwroot", "vendor", "bootstrap", "bootstrap.bundle.min.js");
+            using var client = new HttpClient();
+            var actual = GetFileContent("BTCPayServer", "wwwroot", "vendor", "bootstrap", "bootstrap.bundle.min.js").Trim();
             var version = Regex.Match(actual, "Bootstrap v([0-9]+.[0-9]+.[0-9]+)").Groups[1].Value;
-            var expected = await (await client.GetAsync($"https://cdn.jsdelivr.net/npm/bootstrap@{version}/dist/js/bootstrap.bundle.min.js")).Content.ReadAsStringAsync();
-            Assert.Equal(expected, actual.Replace("\r\n", "\n", StringComparison.OrdinalIgnoreCase));
+            var expected = (await (await client.GetAsync($"https://cdn.jsdelivr.net/npm/bootstrap@{version}/dist/js/bootstrap.bundle.min.js")).Content.ReadAsStringAsync()).Trim();
+            Assert.Equal(expected, actual);
 
             actual = GetFileContent("BTCPayServer", "wwwroot", "vendor", "clipboard.js", "clipboard.js");
-            expected = await (await client.GetAsync($"https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.8/clipboard.js")).Content.ReadAsStringAsync();
-            Assert.Equal(expected, actual.Replace("\r\n", "\n", StringComparison.OrdinalIgnoreCase));
+            expected = (await (await client.GetAsync("https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.8/clipboard.js")).Content.ReadAsStringAsync()).Trim();
+            Assert.Equal(expected, actual);
+
+            actual = GetFileContent("BTCPayServer", "wwwroot", "vendor", "vuejs", "vue.min.js").Trim();
+            version = Regex.Match(actual, "Vue\\.js v([0-9]+.[0-9]+.[0-9]+)").Groups[1].Value;
+            expected = (await (await client.GetAsync($"https://cdnjs.cloudflare.com/ajax/libs/vue/{version}/vue.min.js")).Content.ReadAsStringAsync()).Trim();
+            Assert.Equal(expected, actual);
+
+            actual = GetFileContent("BTCPayServer", "wwwroot", "vendor", "i18next", "i18next.min.js").Trim();
+            expected = (await (await client.GetAsync("https://cdnjs.cloudflare.com/ajax/libs/i18next/22.0.6/i18next.min.js")).Content.ReadAsStringAsync()).Trim();
+            Assert.Equal(expected, actual);
+
+            actual = GetFileContent("BTCPayServer", "wwwroot", "vendor", "i18next", "i18nextHttpBackend.min.js").Trim();
+            expected = (await (await client.GetAsync("https://cdnjs.cloudflare.com/ajax/libs/i18next-http-backend/2.0.1/i18nextHttpBackend.min.js")).Content.ReadAsStringAsync()).Trim();
+            Assert.Equal(expected, actual);
+
+            actual = GetFileContent("BTCPayServer", "wwwroot", "vendor", "i18next", "vue-i18next.js").Trim();
+            expected = (await (await client.GetAsync("https://unpkg.com/@panter/vue-i18next@0.15.2/dist/vue-i18next.js")).Content.ReadAsStringAsync()).Trim();
+            Assert.Equal(expected, actual);
+
+            actual = GetFileContent("BTCPayServer", "wwwroot", "vendor", "vue-qrcode", "vue-qrcode.min.js").Trim();
+            version = Regex.Match(actual, "vue-qrcode v([0-9]+.[0-9]+.[0-9]+)").Groups[1].Value;
+            expected = (await (await client.GetAsync($"https://unpkg.com/@chenfengyuan/vue-qrcode@{version}/dist/vue-qrcode.min.js")).Content.ReadAsStringAsync()).Trim();
+            Assert.Equal(expected, actual);
         }
+        
         string GetFileContent(params string[] path)
         {
             var l = path.ToList();

BTCPayServer.Tests/UnitTest1.cs

@@ -40,6 +40,7 @@ using BTCPayServer.Security.Bitpay;
 using BTCPayServer.Services;
 using BTCPayServer.Services.Apps;
 using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Labels;
 using BTCPayServer.Services.Mails;
 using BTCPayServer.Services.Rates;
 using BTCPayServer.Storage.Models;
@@ -51,6 +52,7 @@ using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 using NBitcoin;
 using NBitcoin.DataEncoders;
 using NBitcoin.Payment;
@@ -652,8 +654,8 @@ namespace BTCPayServer.Tests
                 (string)store2.TempData[WellKnownTempData.ErrorMessage], StringComparison.CurrentCultureIgnoreCase);
         }
 
-        [Fact(Timeout = LongRunningTestTimeout)]
-        [Trait("Integration", "Integration")]
+        [Fact(Timeout = LongRunningTestTimeout * 2)]
+        [Trait("Flaky", "Flaky")]
         public async Task CanUseTorClient()
         {
             using var tester = CreateServerTester();
@@ -785,9 +787,9 @@ namespace BTCPayServer.Tests
             tx = Assert.Single(transactions.Transactions);
 
             Assert.Equal("hello", tx.Comment);
-            Assert.Contains("test", tx.Labels.Select(l => l.Text));
-            Assert.Contains("test2", tx.Labels.Select(l => l.Text));
-            Assert.Equal(2, tx.Labels.GroupBy(l => l.Color).Count());
+            Assert.Contains("test", tx.Tags.Select(l => l.Text));
+            Assert.Contains("test2", tx.Tags.Select(l => l.Text));
+            Assert.Equal(2, tx.Tags.GroupBy(l => l.Color).Count());
 
             Assert.IsType<RedirectToActionResult>(
                 await walletController.ModifyTransaction(walletId, tx.Id, removelabel: "test2"));
@@ -797,12 +799,9 @@ namespace BTCPayServer.Tests
             tx = Assert.Single(transactions.Transactions);
 
             Assert.Equal("hello", tx.Comment);
-            Assert.Contains("test", tx.Labels.Select(l => l.Text));
-            Assert.DoesNotContain("test2", tx.Labels.Select(l => l.Text));
-            Assert.Single(tx.Labels.GroupBy(l => l.Color));
-
-            var walletInfo = await tester.PayTester.GetService<WalletRepository>().GetWalletInfo(walletId);
-            Assert.Single(walletInfo.LabelColors); // the test2 color should have been removed
+            Assert.Contains("test", tx.Tags.Select(l => l.Text));
+            Assert.DoesNotContain("test2", tx.Tags.Select(l => l.Text));
+            Assert.Single(tx.Tags.GroupBy(l => l.Color));
         }
 
         [Fact(Timeout = LongRunningTestTimeout)]
@@ -1753,7 +1752,7 @@ namespace BTCPayServer.Tests
             await user.GrantAccessAsync();
             user.RegisterDerivationScheme("BTC");
             await user.SetNetworkFeeMode(NetworkFeeMode.Always);
-            var invoice = user.BitPay.CreateInvoice(
+            var invoice = await user.BitPay.CreateInvoiceAsync(
                 new Invoice
                 {
                     Price = 10,
@@ -1768,7 +1767,7 @@ namespace BTCPayServer.Tests
             var jsonResult = user.GetController<UIInvoiceController>().Export("json").GetAwaiter().GetResult();
             var result = Assert.IsType<ContentResult>(jsonResult);
             Assert.Equal("application/json", result.ContentType);
-            Assert.Equal(1, JArray.Parse(result.Content).Count);
+            Assert.Single(JArray.Parse(result.Content));
 
             var cashCow = tester.ExplorerNode;
             var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
@@ -2521,6 +2520,79 @@ namespace BTCPayServer.Tests
             Assert.True(lnMethod.IsInternalNode);
         }
 
+        [Fact(Timeout = LongRunningTestTimeout)]
+        [Trait("Integration", "Integration")]
+        [Obsolete]
+        public async Task CanDoLabelMigrations()
+        {
+            using var tester = CreateServerTester(newDb: true);
+            await tester.StartAsync();
+            var dbf = tester.PayTester.GetService<ApplicationDbContextFactory>();
+            int walletCount = 1000;
+            var wallet = "walletttttttttttttttttttttttttttt";
+            using (var db = dbf.CreateContext())
+            {
+                for (int i = 0; i < walletCount; i++)
+                {
+                    var walletData = new WalletData() { Id = $"S-{wallet}{i}-BTC" };
+                    walletData.Blob = ZipUtils.Zip("{\"LabelColors\": { \"label1\" : \"black\", \"payout\":\"green\" }}");
+                    db.Wallets.Add(walletData);
+                }
+                await db.SaveChangesAsync();
+            }
+            uint256 firstTxId = null;
+            using (var db = dbf.CreateContext())
+            {
+                int transactionCount = 10_000;
+                for (int i = 0; i < transactionCount; i++)
+                {
+                    var txId = RandomUtils.GetUInt256();
+                    var wt = new WalletTransactionData()
+                    {
+                        WalletDataId = $"S-{wallet}{i % walletCount}-BTC",
+                        TransactionId = txId.ToString(),
+                    };
+                    firstTxId ??= txId;
+                    if (i != 10)
+                        wt.Blob = ZipUtils.Zip("{\"Comment\":\"test\"}");
+                    if (i % 1240 != 0)
+                    {
+                        wt.Labels = "[{\"type\":\"raw\", \"text\":\"label1\"}]";
+                    }
+                    else if (i == 0)
+                    {
+                        wt.Labels = "[{\"type\":\"raw\", \"text\":\"label1\"},{\"type\":\"raw\", \"text\":\"labelo" + i + "\"}, " +
+                            "{\"type\":\"payout\", \"text\":\"payout\", \"pullPaymentPayouts\":{\"pp1\":[\"p1\",\"p2\"],\"pp2\":[\"p3\"]}}]";
+                    }
+                    else
+                    {
+                        wt.Labels = "[{\"type\":\"raw\", \"text\":\"label1\"},{\"type\":\"raw\", \"text\":\"labelo" + i + "\"}]";
+                    }
+                    db.WalletTransactions.Add(wt);
+                }
+                await db.SaveChangesAsync();
+            }
+            await RestartMigration(tester);
+            var migrator = tester.PayTester.GetService<IEnumerable<IHostedService>>().OfType<DbMigrationsHostedService>().First();
+            await migrator.MigratedTransactionLabels(0);
+
+            var walletRepo = tester.PayTester.GetService<WalletRepository>();
+            var wi1 = await walletRepo.GetWalletLabels(new WalletId($"{wallet}0", "BTC"));
+            Assert.Equal(3, wi1.Length);
+            Assert.Contains(wi1, o => o.Label == "label1" && o.Color == "black");
+            Assert.Contains(wi1, o => o.Label == "labelo0" && o.Color == "#000");
+            Assert.Contains(wi1, o => o.Label == "payout" && o.Color == "green");
+
+            var txInfo = await walletRepo.GetWalletTransactionsInfo(new WalletId($"{wallet}0", "BTC"), new[] { firstTxId.ToString() });
+            Assert.Equal("test", txInfo.Values.First().Comment);
+            // Should have the 2 raw labels, and one legacy label for payouts
+            Assert.Equal(3, txInfo.Values.First().LegacyLabels.Count);
+            var payoutLabel = txInfo.Values.First().LegacyLabels.Select(l => l.Value).OfType<PayoutLabel>().First();
+            Assert.Equal(2, payoutLabel.PullPaymentPayouts.Count);
+            Assert.Equal(2, payoutLabel.PullPaymentPayouts["pp1"].Count);
+            Assert.Single(payoutLabel.PullPaymentPayouts["pp2"]);
+        }
+
 
         [Fact(Timeout = LongRunningTestTimeout)]
         [Trait("Integration", "Integration")]

BTCPayServer.Tests/docker-bitcoin-multisig-setup.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+
+# Creates a 2-of-3 multisig setup, following the procedure described here:
+# https://github.com/bitcoin/bitcoin/blob/master/doc/multisig-tutorial.md
+# https://github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md
+#
+# Usage:
+# ./docker-bitcoin-multisig-setup.sh custom-name
+#
+# The custom name/prefix is optional and defaults to "multisig".
+prefix="${1:-"multi_sig"}"
+
+declare -A xpubs
+
+printf "\n👛 Create descriptor wallets\n\n"
+for ((n=1;n<=3;n++)); do
+  # Create descriptor wallets, surpress error output in case wallet already exists
+  ./docker-bitcoin-cli.sh -named createwallet wallet_name="${prefix}_part_${n}" descriptors=true > /dev/null 2>&1
+
+  # Collect xpubs
+  ./docker-bitcoin-cli.sh -rpcwallet="${prefix}_part_${n}" listdescriptors > /dev/null 2>&1
+  xpubs["internal_xpub_${n}"]=$(./docker-bitcoin-cli.sh -rpcwallet="${prefix}_part_${n}" listdescriptors | jq '.descriptors | [.[] | select(.desc | startswith("wpkh") and contains("/1/*"))][0] | .desc' | grep -Po '(?<=\().*(?=\))')
+  xpubs["external_xpub_${n}"]=$(./docker-bitcoin-cli.sh -rpcwallet="${prefix}_part_${n}" listdescriptors | jq '.descriptors | [.[] | select(.desc | startswith("wpkh") and contains("/0/*"))][0] | .desc' | grep -Po '(?<=\().*(?=\))')
+done
+
+for x in "${!xpubs[@]}"; do
+  printf "[%s]=%s\n" "$x" "${xpubs[$x]}";
+done
+
+external_desc="wsh(sortedmulti(2,${xpubs["external_xpub_1"]},${xpubs["external_xpub_2"]},${xpubs["external_xpub_3"]}))"
+internal_desc="wsh(sortedmulti(2,${xpubs["internal_xpub_1"]},${xpubs["internal_xpub_2"]},${xpubs["internal_xpub_3"]}))"
+
+external_desc_sum=$(./docker-bitcoin-cli.sh getdescriptorinfo $external_desc | jq '.descriptor')
+internal_desc_sum=$(./docker-bitcoin-cli.sh getdescriptorinfo $internal_desc | jq '.descriptor')
+
+multisig_ext_desc="{\"desc\": $external_desc_sum, \"active\": true, \"internal\": false, \"timestamp\": \"now\"}"
+multisig_int_desc="{\"desc\": $internal_desc_sum, \"active\": true, \"internal\": true, \"timestamp\": \"now\"}"
+
+multisig_desc="[$multisig_ext_desc, $multisig_int_desc]"
+
+# Create multisig wallet, surpress error output in case wallet already exists
+
+printf "\n🔐 Create multisig wallet\n"
+printf "\nExternal descriptor: $external_desc\n"
+printf "\nInternal descriptor: $internal_desc\n"
+
+multisig_name="${prefix}_wallet"
+./docker-bitcoin-cli.sh -named createwallet wallet_name="$multisig_name" disable_private_keys=true blank=true descriptors=true > /dev/null 2>&1
+./docker-bitcoin-cli.sh -rpcwallet="$multisig_name" importdescriptors "$multisig_desc" > /dev/null 2>&1
+
+# Fund the wallet from the default wallet
+printf "\n💰 Fund multisig wallet\n"
+
+newaddress=$(./docker-bitcoin-cli.sh -rpcwallet="$multisig_name" getnewaddress "MultiSig Funding" | tr -d "[:cntrl:]")
+txid=$(./docker-bitcoin-cli.sh -rpcwallet="" sendtoaddress "$newaddress" 0.615)
+printf "\nReceiving address: $newaddress\n"
+printf "\nTransaction ID: $txid\n"
+
+# Confirm everything worked
+printf "\nℹ️  Multisig wallet info\n\n"
+./docker-bitcoin-cli.sh -rpcwallet="$multisig_name" getwalletinfo
+
+# Unload wallets to prevent having to specify which wallet to use in BTCPay, NBXplorer etc.
+for ((n=1;n<=3;n++)); do
+  ./docker-bitcoin-cli.sh unloadwallet "${prefix}_part_${n}" > /dev/null 2>&1
+done
+./docker-bitcoin-cli.sh unloadwallet "$multisig_name" > /dev/null 2>&1

BTCPayServer.Tests/docker-compose.altcoins.yml

@@ -71,7 +71,7 @@ services:
         - "sshd_datadir:/root/.ssh"
 
   devlnd:
-    image: btcpayserver/bitcoin:22.0
+    image: btcpayserver/bitcoin:23.0-1
     environment:
       BITCOIN_NETWORK: regtest
       BITCOIN_WALLETDIR: "/data/wallets"
@@ -90,7 +90,7 @@ services:
     expose:
       - "4444"
   nbxplorer:
-    image: nicolasdorier/nbxplorer:2.3.14
+    image: nicolasdorier/nbxplorer:2.3.40
     restart: unless-stopped
     ports:
       - "32838:32838"
@@ -126,7 +126,7 @@ services:
 
   bitcoind:
     restart: unless-stopped
-    image: btcpayserver/bitcoin:22.0
+    image: btcpayserver/bitcoin:23.0-1
     environment:
       BITCOIN_NETWORK: regtest
       BITCOIN_WALLETDIR: "/data/wallets"
@@ -237,7 +237,7 @@ services:
       - "5432"
 
   merchant_lnd:
-    image: btcpayserver/lnd:v0.15.0-beta
+    image: btcpayserver/lnd:v0.15.4-beta-1
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"
@@ -272,7 +272,7 @@ services:
       - bitcoind
 
   customer_lnd:
-    image: btcpayserver/lnd:v0.15.0-beta
+    image: btcpayserver/lnd:v0.15.4-beta-1
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"

BTCPayServer.Tests/docker-compose.yml

@@ -68,7 +68,7 @@ services:
         - "sshd_datadir:/root/.ssh"
 
   devlnd:
-    image: btcpayserver/bitcoin:22.0
+    image: btcpayserver/bitcoin:23.0-1
     environment:
       BITCOIN_NETWORK: regtest
       BITCOIN_WALLETDIR: "/data/wallets"
@@ -87,7 +87,7 @@ services:
     expose:
       - "4444"
   nbxplorer:
-    image: nicolasdorier/nbxplorer:2.3.14
+    image: nicolasdorier/nbxplorer:2.3.40
     restart: unless-stopped
     ports:
       - "32838:32838"
@@ -113,7 +113,7 @@ services:
 
   bitcoind:
     restart: unless-stopped
-    image: btcpayserver/bitcoin:22.0
+    image: btcpayserver/bitcoin:23.0-1
     environment:
       BITCOIN_NETWORK: regtest
       BITCOIN_WALLETDIR: "/data/wallets"
@@ -225,7 +225,7 @@ services:
       - "5432"
 
   merchant_lnd:
-    image: btcpayserver/lnd:v0.15.0-beta
+    image: btcpayserver/lnd:v0.15.4-beta-1
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"
@@ -262,7 +262,7 @@ services:
       - bitcoind
 
   customer_lnd:
-    image: btcpayserver/lnd:v0.15.0-beta
+    image: btcpayserver/lnd:v0.15.4-beta-1
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"

BTCPayServer/BTCPayServer.csproj

@@ -1,24 +1,26 @@
- <Project Sdk="Microsoft.NET.Sdk.Web">
+ <Project Sdk="Microsoft.NET.Sdk.Web">
   <Import Project="../Build/Version.csproj" Condition="Exists('../Build/Version.csproj')" />
   <Import Project="../Build/Common.csproj" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-
     <PreserveCompilationContext>true</PreserveCompilationContext>
+    <RunAnalyzersDuringLiveAnalysis>False</RunAnalyzersDuringLiveAnalysis>
+    <RunAnalyzersDuringBuild>False</RunAnalyzersDuringBuild>
   </PropertyGroup>
+   <ItemGroup>
+     <AssemblyAttribute Condition="'$(GitCommit)' != ''" Include="BTCPayServer.GitCommitAttribute">
+       <_Parameter1>$(GitCommit)</_Parameter1>
+     </AssemblyAttribute>
+   </ItemGroup>
   <ItemGroup>
     <Compile Remove="Build\**" />
-    <Compile Remove="wwwroot\bundles\jqueryvalidate\**" />
     <Compile Remove="wwwroot\vendor\jquery-nice-select\**" />
     <Content Remove="Build\**" />
-    <Content Remove="wwwroot\bundles\jqueryvalidate\**" />
     <Content Remove="wwwroot\vendor\jquery-nice-select\**" />
     <EmbeddedResource Remove="Build\**" />
-    <EmbeddedResource Remove="wwwroot\bundles\jqueryvalidate\**" />
     <EmbeddedResource Remove="wwwroot\vendor\jquery-nice-select\**" />
     <None Remove="Build\**" />
-    <None Remove="wwwroot\bundles\jqueryvalidate\**" />
     <None Remove="wwwroot\vendor\jquery-nice-select\**" />
     <Content Update="Views\UIStorePullPayments\NewPullPayment.cshtml">
       <Pack>false</Pack>
@@ -33,9 +35,6 @@
   <ItemGroup>
     <None Remove="Currencies.txt" />
   </ItemGroup>
-  <ItemGroup>
-    <EmbeddedResource Include="bundleconfig.json" />
-  </ItemGroup>
 
   <ItemGroup Condition="'$(Altcoins)' != 'true'">
     <Content Remove="Services\Altcoins\**\*" />
@@ -48,23 +47,15 @@
   <ItemGroup>
     <PackageReference Include="BIP78.Sender" Version="0.2.2" />
     <PackageReference Include="BTCPayServer.Hwi" Version="2.0.2" />
-    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.4.4" />
-    <PackageReference Include="BuildBundlerMinifier" Version="3.2.449" />
-    <PackageReference Include="BundlerMinifier.Core" Version="3.2.435" />
-    <PackageReference Include="BundlerMinifier.TagHelpers" Version="3.2.435" />
+    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.4.8" />
     <PackageReference Include="CsvHelper" Version="15.0.5" />
     <PackageReference Include="Dapper" Version="2.0.123" />
     <PackageReference Include="Fido2" Version="2.0.2" />
     <PackageReference Include="Fido2.AspNet" Version="2.0.2" />
     <PackageReference Include="HtmlSanitizer" Version="5.0.372" />
-    <PackageReference Include="LNURL" Version="0.0.24" />
+    <PackageReference Include="LNURL" Version="0.0.26" />
     <PackageReference Include="MailKit" Version="3.3.0" />
     <PackageReference Include="McMaster.NETCore.Plugins.Mvc" Version="1.4.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
-    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="3.3.2">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
     <PackageReference Include="QRCoder" Version="1.4.3" />
     <PackageReference Include="System.IO.Pipelines" Version="6.0.3" />
     <PackageReference Include="NBitpayClient" Version="1.0.0.39" />
@@ -72,15 +63,10 @@
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.3" />
     <PackageReference Include="NicolasDorier.RateLimits" Version="1.2.3" />
-    <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.18" />
     <PackageReference Include="Serilog" Version="2.9.0" />
     <PackageReference Include="Serilog.AspNetCore" Version="3.2.0" />
     <PackageReference Include="Serilog.Sinks.File" Version="4.1.0" />
     <PackageReference Include="SSH.NET" Version="2020.0.2" />
-    <PackageReference Include="Text.Analyzers" Version="3.3.3">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
   </ItemGroup>
 
 	<ItemGroup>
@@ -90,8 +76,8 @@
     <PackageReference Include="TwentyTwenty.Storage.Google" Version="2.12.1" />
     <PackageReference Include="TwentyTwenty.Storage.Local" Version="2.12.1" />
 		<PackageReference Include="YamlDotNet" Version="8.0.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation" Version="6.0.7" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="6.0.7" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation" Version="6.0.9" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="6.0.9" />
   </ItemGroup>
 
 	<ItemGroup>

BTCPayServer/ColorPalette.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Drawing;
+using System.Text;
+using System.Text.RegularExpressions;
+using NBitcoin.Crypto;
+
+namespace BTCPayServer
+{
+    public class ColorPalette
+    {
+        public const string Pattern = "^#[0-9a-fA-F]{6}$";
+        public static bool IsValid(string color)
+        {
+            return Regex.Match(color, Pattern).Success;
+        }
+        public string TextColor(string bgColor)
+        {
+            int nThreshold = 105;
+            var bg = ColorTranslator.FromHtml(bgColor);
+            int bgDelta = Convert.ToInt32((bg.R * 0.299) + (bg.G * 0.587) + (bg.B * 0.114));
+            Color color = (255 - bgDelta < nThreshold) ? Color.Black : Color.White;
+            return ColorTranslator.ToHtml(color);
+        }
+        // Borrowed from https://github.com/ManageIQ/guides/blob/master/labels.md
+        public static readonly ColorPalette Default = new ColorPalette(new string[] {
+            "#fbca04",
+            "#0e8a16",
+            "#ff7619",
+            "#84b6eb",
+            "#5319e7",
+            "#cdcdcd",
+            "#cc317c",
+        });
+        private ColorPalette(string[] labels)
+        {
+            Labels = labels;
+        }
+
+        public readonly string[] Labels;
+
+        public string DeterministicColor(string label)
+        {
+            switch (label)
+            {
+                case "payjoin":
+                    return "#51b13e";
+                case "invoice":
+                    return "#cedc21";
+                case "payment-request":
+                    return "#489D77";
+                case "app":
+                    return "#5093B6";
+                case "pj-exposed":
+                    return "#51b13e";
+                case "payout":
+                    return "#3F88AF";
+                default:
+                    var num = NBitcoin.Utils.ToUInt32(Hashes.SHA256(Encoding.UTF8.GetBytes(label)), 0, true);
+                    return Labels[num % Labels.Length];
+            }
+        }
+    }
+}

BTCPayServer/Components/MainLogo/Default.cshtml

@@ -0,0 +1,20 @@
+@using BTCPayServer.Services
+@using BTCPayServer.Abstractions.Contracts
+@using BTCPayServer.Abstractions.Extensions
+@using BTCPayServer.Abstractions.TagHelpers
+@inject ThemeSettings Theme
+@inject IFileService FileService
+@model BTCPayServer.Components.MainLogo.MainLogoViewModel
+
+@if (!string.IsNullOrEmpty(Theme.LogoFileId))
+{
+    var logoSrc = await FileService.GetFileUrl(Context.Request.GetAbsoluteRootUri(), Theme.LogoFileId);
+    <img src="@logoSrc" alt="BTCPay Server" class="main-logo main-logo-custom @Model.CssClass" />
+}
+else
+{
+    <svg xmlns="http://www.w3.org/2000/svg" role="img" alt="BTCPay Server" class="main-logo main-logo-btcpay @Model.CssClass">
+        <use href="/img/logo.svg#small" class="main-logo-btcpay--small"/>
+        <use href="/img/logo.svg#large" class="main-logo-btcpay--large"/>
+    </svg>
+}

BTCPayServer/Components/MainLogo/MainLogo.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace BTCPayServer.Components.MainLogo
+{
+    public class MainLogo : ViewComponent
+    {
+        public IViewComponentResult Invoke(string cssClass = null)
+        {
+            var vm = new MainLogoViewModel
+            {
+                CssClass = cssClass,
+            };
+            return View(vm);
+        }
+    }
+}

BTCPayServer/Components/MainLogo/MainLogoViewModel.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Components.MainLogo
+{
+    public class MainLogoViewModel
+    {
+        public string CssClass { get; set; }
+    }
+}

BTCPayServer/Components/MainNav/Default.cshtml

@@ -9,6 +9,7 @@
 @using BTCPayServer.Client
 @using BTCPayServer.Services
 @using BTCPayServer.Views.CustodianAccounts
+@inject Microsoft.AspNetCore.Http.IHttpContextAccessor HttpContext;
 @inject BTCPayServerEnvironment Env
 @inject SignInManager<ApplicationUser> SignInManager
 @inject PoliciesSettings PoliciesSettings
@@ -227,7 +228,7 @@
                 })()
             </script>
         }
-        else if (Env.IsSecure)
+        else if (Env.IsSecure(HttpContext.HttpContext))
         {
             <ul class="navbar-nav">
                 @if (!PoliciesSettings.LockSubscription)

BTCPayServer/Components/StoreLightningBalance/Default.cshtml

@@ -123,7 +123,10 @@
         </div>
         @if (Model.Balance.OffchainBalance != null && Model.Balance.OnchainBalance != null)
         {
-            <a class="d-inline-block mt-3" role="button" data-bs-toggle="collapse" data-bs-target=".balance-details" aria-expanded="false" aria-controls="balanceDetailsOffchain balanceDetailsOnchain">Show details</a>
+            <button class="d-inline-flex align-items-center btn btn-link text-primary fw-semibold p-0 mt-3 ms-n1" type="button" data-bs-toggle="collapse" data-bs-target=".balance-details" aria-expanded="false" aria-controls="balanceDetailsOffchain balanceDetailsOnchain">
+                <vc:icon symbol="caret-down"/>
+                <span class="ms-1">Details</span>
+            </button>
         }
     }
     else

BTCPayServer/Components/StoreSelector/Default.cshtml

@@ -1,19 +1,24 @@
-@inject BTCPayServer.Services.BTCPayServerEnvironment _env
-@inject SignInManager<ApplicationUser> _signInManager
+@using Microsoft.AspNetCore.Mvc.TagHelpers
+@using BTCPayServer.Abstractions.Extensions
+@using BTCPayServer.Abstractions.Contracts
+@using BTCPayServer.Services
+@inject SignInManager<ApplicationUser> SignInManager
+@inject BTCPayServerEnvironment Env
+@inject IFileService FileService
 @model BTCPayServer.Components.StoreSelector.StoreSelectorViewModel
 @functions {
     @* ReSharper disable once CSharpWarnings::CS1998 *@
 	#pragma warning disable 1998
     private async Task LogoContent()
     {
-        var logoSrc = $"{ViewContext.HttpContext.Request.PathBase}/img/logo.svg";
-        <svg xmlns="http://www.w3.org/2000/svg" role="img" alt="BTCPay Server" class="logo"><use href="@logoSrc#small" class="logo-small" /><use href="@logoSrc#large" class="logo-large" /></svg>
-        @if (_env.NetworkType != NBitcoin.ChainName.Mainnet)
+        <vc:main-logo />
+        @if (Env.NetworkType != NBitcoin.ChainName.Mainnet)
         {
-            <span class="badge bg-warning ms-1 ms-sm-0" style="font-size:10px;">@_env.NetworkType.ToString()</span>
+            var type = Env.NetworkType.ToString();
+            <small class="badge bg-warning rounded-pill ms-1 ms-sm-0" title="@type">@type.Replace("Testnet", "TN").Replace("Regtest", "RT")</small>
         }
     }
-    private string StoreName(string title)
+    private static string StoreName(string title)
     {
         return string.IsNullOrEmpty(title) ? "Unnamed Store" : title;
     }
@@ -21,15 +26,15 @@
 }
 @if (Model.CurrentStoreId == null)
 {
-    <a href="~/" class="navbar-brand py-2 js-scroll-trigger">@{await LogoContent();}</a>
+    <a asp-controller="UIHome" asp-action="Index" id="StoreSelectorHome" class="navbar-brand py-2">@{await LogoContent();}</a>
 }
 else if (Model.CurrentStoreIsOwner)
 {
-    <a asp-controller="UIStores" asp-action="Dashboard" asp-route-storeId="@Model.CurrentStoreId" class="navbar-brand py-2 js-scroll-trigger">@{await LogoContent();}</a>
+    <a asp-controller="UIStores" asp-action="Dashboard" asp-route-storeId="@Model.CurrentStoreId" id="StoreSelectorHome" class="navbar-brand py-2">@{await LogoContent();}</a>
 }
 else
 {
-    <a asp-controller="UIInvoice" asp-action="ListInvoices" asp-route-storeId="@Model.CurrentStoreId" class="navbar-brand py-2 js-scroll-trigger">@{await LogoContent();}</a>
+    <a asp-controller="UIInvoice" asp-action="ListInvoices" asp-route-storeId="@Model.CurrentStoreId" id="StoreSelectorHome" class="navbar-brand py-2">@{await LogoContent();}</a>
 }
 
 <div id="StoreSelector">
@@ -37,7 +42,14 @@ else
     {
         <div id="StoreSelectorDropdown" class="dropdown only-for-js">
             <button id="StoreSelectorToggle" class="btn btn-secondary dropdown-toggle rounded-pill px-3 @(Model.CurrentStoreId == null ? "text-secondary" : "")" type="button" data-bs-toggle="dropdown" aria-expanded="false">
-                <vc:icon symbol="store"/>
+                @if (!string.IsNullOrEmpty(Model.CurrentStoreLogoFileId))
+                {
+                    <img class="logo" src="@(await FileService.GetFileUrl(Context.Request.GetAbsoluteRootUri(), Model.CurrentStoreLogoFileId))" alt="@Model.CurrentDisplayName" />
+                }
+                else
+                {
+                    <vc:icon symbol="store"/>
+                }
                 <span>@(Model.CurrentStoreId == null ? "Select Store" : Model.CurrentDisplayName)</span>
                 <vc:icon symbol="caret-down"/>
             </button>
@@ -60,7 +72,7 @@ else
             </ul>
         </div>
     }
-    else if (_signInManager.IsSignedIn(User))
+    else if (SignInManager.IsSignedIn(User))
     {
         <a asp-controller="UIUserStores" asp-action="CreateStore" class="btn btn-primary w-100 rounded-pill" id="StoreSelectorCreate">Create Store</a>
     }

BTCPayServer/Components/StoreSelector/StoreSelector.cs

@@ -50,12 +50,15 @@ namespace BTCPayServer.Components.StoreSelector
                 .OrderBy(s => s.Text)
                 .ToList();
 
+            var blob = currentStore?.GetStoreBlob();
+
             var vm = new StoreSelectorViewModel
             {
                 Options = options,
                 CurrentStoreId = currentStore?.Id,
                 CurrentDisplayName = currentStore?.StoreName,
-                CurrentStoreIsOwner = currentStore?.Role == StoreRoles.Owner
+                CurrentStoreIsOwner = currentStore?.Role == StoreRoles.Owner,
+                CurrentStoreLogoFileId = blob?.LogoFileId
             };
 
             return View(vm);

BTCPayServer/Components/StoreSelector/StoreSelectorViewModel.cs

@@ -6,6 +6,7 @@ namespace BTCPayServer.Components.StoreSelector
     {
         public List<StoreSelectorOption> Options { get; set; }
         public string CurrentStoreId { get; set; }
+        public string CurrentStoreLogoFileId { get; set; }
         public string CurrentDisplayName { get; set; }
         public bool CurrentStoreIsOwner { get; set; }
     }

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -65,11 +65,7 @@ namespace BTCPayServer.Configuration
             if (conf.GetOrDefault<bool>("launchsettings", false) && NetworkType != ChainName.Regtest)
                 throw new ConfigException($"You need to run BTCPayServer with the run.sh or run.ps1 script");
 
-
-
-            BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
             DockerDeployment = conf.GetOrDefault<bool>("dockerdeployment", true);
-
             TorrcFile = conf.GetOrDefault<string>("torrcfile", null);
             TorServices = conf.GetOrDefault<string>("torservices", null)
                 ?.Split(new[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries);
@@ -112,9 +108,9 @@ namespace BTCPayServer.Configuration
                 {
                     Logs.Configuration.LogWarning($"The SSH key is not supported ({ex.Message}), try to generate the key with ssh-keygen using \"-m PEM\". Skipping SSH configuration...");
                 }
-                catch
+                catch (Exception ex)
                 {
-                    throw new ConfigException($"sshkeyfilepassword is invalid");
+                    Logs.Configuration.LogWarning(ex, "Error while loading SSH settings");
                 }
             }
 
@@ -144,14 +140,15 @@ namespace BTCPayServer.Configuration
             }
 
             DisableRegistration = conf.GetOrDefault<bool>("disable-registration", true);
-            PluginRemote = conf.GetOrDefault("plugin-remote", "btcpayserver/btcpayserver-plugins");
+            var pluginRemote = conf.GetOrDefault<string>("plugin-remote", null);
+            if (pluginRemote != null)
+                Logs.Configuration.LogWarning("plugin-remote is an obsolete configuration setting, please remove it from configuration");
             RecommendedPlugins = conf.GetOrDefault("recommended-plugins", "").ToLowerInvariant().Split('\r', '\n', '\t', ' ').Where(s => !string.IsNullOrEmpty(s)).Distinct().ToArray();
             CheatMode = conf.GetOrDefault("cheatmode", false);
             if (CheatMode && this.NetworkType == ChainName.Mainnet)
                 throw new ConfigException($"cheatmode can't be used on mainnet");
         }
 
-        public string PluginRemote { get; set; }
         public string[] RecommendedPlugins { get; set; }
         public bool CheatMode { get; set; }
 
@@ -192,16 +189,7 @@ namespace BTCPayServer.Configuration
 
         public string RootPath { get; set; }
         public bool DockerDeployment { get; set; }
-        public bool BundleJsCss
-        {
-            get;
-            set;
-        }
-        public SSHSettings SSHSettings
-        {
-            get;
-            set;
-        }
+        public SSHSettings SSHSettings { get; set; }
         public string TorrcFile { get; set; }
         public string[] TorServices { get; set; }
         public Uri UpdateUrl { get; set; }

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -31,7 +31,6 @@ namespace BTCPayServer.Configuration
             app.Option("--nocsp", $"Disable CSP (default false)", CommandOptionType.BoolValue);
             app.Option("--sqlitefile", $"File name to an SQLite database file inside the data directory", CommandOptionType.SingleValue);
             app.Option("--externalservices", $"Links added to external services inside Server Settings / Services under the format service1:path2;service2:path2.(default: empty)", CommandOptionType.SingleValue);
-            app.Option("--bundlejscss", $"Bundle JavaScript and CSS files for better performance (default: true)", CommandOptionType.SingleValue);
             app.Option("--rootpath", "The root path in the URL to access BTCPay (default: /)", CommandOptionType.SingleValue);
             app.Option("--sshconnection", "SSH server to manage BTCPay under the form user@server:port (default: root@externalhost or empty)", CommandOptionType.SingleValue);
             app.Option("--sshpassword", "SSH password to manage BTCPay (default: empty)", CommandOptionType.SingleValue);
@@ -46,7 +45,7 @@ namespace BTCPayServer.Configuration
             app.Option("--debuglog", "A rolling log file for debug messages.", CommandOptionType.SingleValue);
             app.Option("--debugloglevel", "The severity you log (default:information)", CommandOptionType.SingleValue);
             app.Option("--disable-registration", "Disables new user registrations (default:true)", CommandOptionType.SingleValue);
-            app.Option("--plugin-remote", "Which github repository to fetch the available plugins list (default:btcpayserver/btcpayserver-plugins)", CommandOptionType.SingleValue);
+            app.Option("--plugin-remote", "Obsolete, do not use", CommandOptionType.SingleValue);
             app.Option("--recommended-plugins", "Plugins which would be marked as recommended to be installed. Separated by newline or space", CommandOptionType.MultipleValue);
             app.Option("--xforwardedproto", "If specified, set X-Forwarded-Proto to the specified value, this may be useful if your reverse proxy handle https but is not configured to add X-Forwarded-Proto (example: --xforwardedproto https)", CommandOptionType.SingleValue);
             app.Option("--cheatmode", "Add some helper UI to facilitate dev-time testing (Default false)", CommandOptionType.BoolValue);
@@ -139,6 +138,7 @@ namespace BTCPayServer.Configuration
             {
                 builder.AppendLine(CultureInfo.InvariantCulture, $"#{n.CryptoCode}.explorer.url={n.NBXplorerNetwork.DefaultSettings.DefaultUrl}");
                 builder.AppendLine(CultureInfo.InvariantCulture, $"#{n.CryptoCode}.explorer.cookiefile={ n.NBXplorerNetwork.DefaultSettings.DefaultCookieFile}");
+                builder.AppendLine(CultureInfo.InvariantCulture, $"#{n.CryptoCode}.blockexplorerlink=https://mempool.space/tx/{{0}}");
                 if (n.SupportLightning)
                 {
                     builder.AppendLine(CultureInfo.InvariantCulture, $"#{n.CryptoCode}.lightning=/root/.lightning/lightning-rpc");

BTCPayServer/Configuration/ExternalConnectionString.cs

@@ -77,7 +77,8 @@ namespace BTCPayServer.Configuration
                 }
             }
 
-            if (new[] { ExternalServiceTypes.Charge, ExternalServiceTypes.RTL, ExternalServiceTypes.ThunderHub, ExternalServiceTypes.Spark, ExternalServiceTypes.Configurator }.Contains(serviceType))
+            if (new[] { ExternalServiceTypes.Charge, ExternalServiceTypes.RTL, ExternalServiceTypes.ThunderHub,
+                ExternalServiceTypes.Spark, ExternalServiceTypes.Configurator, ExternalServiceTypes.Torq }.Contains(serviceType))
             {
                 // Read access key from cookie file
                 if (connectionString.CookieFilePath != null)
@@ -97,7 +98,8 @@ namespace BTCPayServer.Configuration
                     }
                     connectionString.CookieFilePath = null;
                     
-                    if (serviceType == ExternalServiceTypes.RTL || serviceType == ExternalServiceTypes.Configurator || serviceType == ExternalServiceTypes.ThunderHub)
+                    if (serviceType == ExternalServiceTypes.RTL || serviceType == ExternalServiceTypes.Configurator ||
+                        serviceType == ExternalServiceTypes.ThunderHub || serviceType == ExternalServiceTypes.Torq)
                     {
                         connectionString.AccessKey = cookieFileContent;
                     }

BTCPayServer/Configuration/ExternalService.cs

@@ -36,6 +36,10 @@ namespace BTCPayServer.Configuration
                                 $"Valid example: 'server=https://btcpay.example.com/rtl/btc/;cookiefile=/etc/clightning_bitcoin_rtl/.cookie'" + Environment.NewLine +
                                 "Error: {1}",
                                 "Ride The Lightning");
+            Load(configuration, cryptoCode, "torq", ExternalServiceTypes.Torq, "Invalid setting {0}, " + Environment.NewLine +
+                                $"Valid example: 'server=https://btcpay.example.com/torq/cookie-login/;cookiefile=/etc/lnd_bitcoin_rtl/.cookie'" + Environment.NewLine +
+                                "Error: {1}",
+                                "Torq");
             Load(configuration, cryptoCode, "thunderhub", ExternalServiceTypes.ThunderHub, "Invalid setting {0}, " + Environment.NewLine +
                                 $"Valid example: 'server=https://btcpay.example.com/thub/;cookiefile=/etc/clightning_bitcoin_rtl/.cookie'" + Environment.NewLine +
                                 "Error: {1}",
@@ -93,7 +97,8 @@ namespace BTCPayServer.Configuration
         {
             ExternalServiceTypes.Spark,
             ExternalServiceTypes.RTL,
-            ExternalServiceTypes.ThunderHub
+            ExternalServiceTypes.ThunderHub,
+            ExternalServiceTypes.Torq
         };
         
         public static readonly string[] LightningServiceNames =
@@ -130,6 +135,7 @@ namespace BTCPayServer.Configuration
         P2P,
         RPC,
         Configurator,
-        CLightningRest
+        CLightningRest,
+        Torq
     }
 }

BTCPayServer/Controllers/GreenField/GreenfieldAppsController.cs

@@ -1,5 +1,6 @@
 #nullable enable
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Abstractions.Constants;
 using BTCPayServer.Client;
@@ -38,6 +39,37 @@ namespace BTCPayServer.Controllers.Greenfield
             _currencies = currencies;
         }
 
+        [HttpPost("~/api/v1/stores/{storeId}/apps/crowdfund")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> CreateCrowdfundApp(string storeId, CreateCrowdfundAppRequest request)
+        {
+            var store = await _storeRepository.FindStore(storeId);
+            if (store == null)
+                return this.CreateAPIError(404, "store-not-found", "The store was not found");
+
+            // This is not obvious but we must have a non-null currency or else request validation may work incorrectly
+            request.TargetCurrency = request.TargetCurrency ?? store.GetStoreBlob().DefaultCurrency;
+
+            var validationResult = ValidateCrowdfundAppRequest(request);
+            if (validationResult != null)
+            {
+                return validationResult;
+            }
+
+            var appData = new AppData
+            {
+                StoreDataId = storeId,
+                Name = request.AppName,
+                AppType = AppType.Crowdfund.ToString()
+            };
+
+            appData.SetSettings(ToCrowdfundSettings(request));
+
+            await _appService.UpdateOrCreateApp(appData);
+
+            return Ok(ToCrowdfundModel(appData));
+        }
+
         [HttpPost("~/api/v1/stores/{storeId}/apps/pos")]
         [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
         public async Task<IActionResult> CreatePointOfSaleApp(string storeId, CreatePointOfSaleAppRequest request)
@@ -66,7 +98,7 @@ namespace BTCPayServer.Controllers.Greenfield
 
             await _appService.UpdateOrCreateApp(appData);
 
-            return Ok(ToModel(appData));
+            return Ok(ToPointOfSaleModel(appData));
         }
 
         [HttpPut("~/api/v1/apps/pos/{appId}")]
@@ -95,7 +127,7 @@ namespace BTCPayServer.Controllers.Greenfield
             
             await _appService.UpdateOrCreateApp(app);
 
-            return Ok(ToModel(app));
+            return Ok(ToPointOfSaleModel(app));
         }
 
         private RequiresRefundEmail? BoolToRequiresRefundEmail(bool? requiresRefundEmail)
@@ -115,7 +147,7 @@ namespace BTCPayServer.Controllers.Greenfield
         [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
         public async Task<IActionResult> GetApp(string appId)
         {
-            var app = await _appService.GetApp(appId, AppType.PointOfSale);
+            var app = await _appService.GetApp(appId, null);
             if (app == null)
             {
                 return AppNotFound();
@@ -143,6 +175,43 @@ namespace BTCPayServer.Controllers.Greenfield
             return this.CreateAPIError(404, "app-not-found", "The app with specified ID was not found");
         }
 
+        private CrowdfundSettings ToCrowdfundSettings(CreateCrowdfundAppRequest request)
+        {
+            var parsedSounds = ValidateStringArray(request.Sounds);
+            var parsedColors = ValidateStringArray(request.AnimationColors);
+
+            return new CrowdfundSettings
+            {
+                Title = request.Title?.Trim(),
+                Enabled = request.Enabled ?? true,
+                EnforceTargetAmount = request.EnforceTargetAmount ?? false,
+                StartDate = request.StartDate?.UtcDateTime,
+                TargetCurrency = request.TargetCurrency?.Trim(),
+                Description = request.Description?.Trim(),
+                EndDate = request.EndDate?.UtcDateTime,
+                TargetAmount = request.TargetAmount,
+                CustomCSSLink = request.CustomCSSLink?.Trim(),
+                MainImageUrl = request.MainImageUrl?.Trim(),
+                EmbeddedCSS = request.EmbeddedCSS?.Trim(),
+                NotificationUrl = request.NotificationUrl?.Trim(),
+                Tagline = request.Tagline?.Trim(),
+                PerksTemplate = request.PerksTemplate != null ? _appService.SerializeTemplate(_appService.Parse(request.PerksTemplate?.Trim(), request.TargetCurrency)) : null,
+                // If Disqus shortname is not null or empty we assume that Disqus should be enabled
+                DisqusEnabled = !string.IsNullOrEmpty(request.DisqusShortname?.Trim()),
+                DisqusShortname = request.DisqusShortname?.Trim(),
+                // If explicit parameter is not passed for enabling sounds/animations, turn them on if custom sounds/colors are passed
+                SoundsEnabled = request.SoundsEnabled ?? parsedSounds != null,
+                AnimationsEnabled = request.AnimationsEnabled ?? parsedColors != null,
+                ResetEveryAmount = request.ResetEveryAmount ?? 1,
+                ResetEvery = (Services.Apps.CrowdfundResetEvery)request.ResetEvery,
+                DisplayPerksValue = request.DisplayPerksValue ?? false,
+                DisplayPerksRanking = request.DisplayPerksRanking ?? false,
+                SortPerksByPopularity = request.SortPerksByPopularity ?? false,
+                Sounds = parsedSounds ?? new CrowdfundSettings().Sounds,
+                AnimationColors = parsedColors ?? new CrowdfundSettings().AnimationColors
+            };
+        }
+
         private PointOfSaleSettings ToPointOfSaleSettings(CreatePointOfSaleAppRequest request)
         {
             return new PointOfSaleSettings()
@@ -164,13 +233,25 @@ namespace BTCPayServer.Controllers.Greenfield
                 EmbeddedCSS = request.EmbeddedCSS,
                 RedirectAutomatically = request.RedirectAutomatically,
                 RequiresRefundEmail = BoolToRequiresRefundEmail(request.RequiresRefundEmail) ?? RequiresRefundEmail.InheritFromStore,
+                FormId = request.FormId,
+                CheckoutType = request.CheckoutType ?? CheckoutType.V1
             };
         }
 
-        private PointOfSaleAppData ToModel(AppData appData)
+        private AppDataBase ToModel(AppData appData)
         {
-            var settings = appData.GetSettings<PointOfSaleSettings>();
+            return new AppDataBase
+            {
+                Id = appData.Id,
+                AppType = appData.AppType,
+                Name = appData.Name,
+                StoreId = appData.StoreDataId,
+                Created = appData.Created,
+            };
+        }
 
+        private PointOfSaleAppData ToPointOfSaleModel(AppData appData)
+        {
             return new PointOfSaleAppData
             {
                 Id = appData.Id,
@@ -209,6 +290,84 @@ namespace BTCPayServer.Controllers.Greenfield
             return validationResult;
         }
 
+        private CrowdfundAppData ToCrowdfundModel(AppData appData)
+        {
+            return new CrowdfundAppData
+            {
+                Id = appData.Id,
+                AppType = appData.AppType,
+                Name = appData.Name,
+                StoreId = appData.StoreDataId,
+                Created = appData.Created
+            };
+        }
+
+        private string[]? ValidateStringArray(string[]? arr)
+        {
+            if (arr == null || !arr.Any()) 
+            {
+                return null;
+            }
+
+            // Make sure it's not just an array of empty strings
+            if (arr.All(s => string.IsNullOrEmpty(s.Trim())))
+            {
+                return null;
+            }
+
+            return arr.Select(s => s.Trim()).ToArray();
+        }
+
+        private IActionResult? ValidateCrowdfundAppRequest(CreateCrowdfundAppRequest request)
+        {
+            var validationResult = ValidateCreateAppRequest(request);
+            if (request.TargetCurrency != null && _currencies.GetCurrencyData(request.TargetCurrency, false) == null)
+            {
+                ModelState.AddModelError(nameof(request.TargetCurrency), "Invalid currency");
+            }
+
+            try
+            {
+                _appService.SerializeTemplate(_appService.Parse(request.PerksTemplate, request.TargetCurrency));
+            }
+            catch
+            {
+                ModelState.AddModelError(nameof(request.PerksTemplate), "Invalid template");
+            }
+
+            if (request.ResetEvery != Client.Models.CrowdfundResetEvery.Never && request.StartDate == null)
+            {
+                ModelState.AddModelError(nameof(request.StartDate), "A start date is needed when the goal resets every X amount of time");
+            }
+
+            if (request.ResetEvery != Client.Models.CrowdfundResetEvery.Never && request.ResetEveryAmount <= 0)
+            {
+                ModelState.AddModelError(nameof(request.ResetEveryAmount), "You must reset the goal at a minimum of 1");
+            }
+
+            if (request.Sounds != null && ValidateStringArray(request.Sounds) == null)
+            {
+                ModelState.AddModelError(nameof(request.Sounds), "Sounds must be a non-empty array of non-empty strings");
+            }
+
+            if (request.AnimationColors != null && ValidateStringArray(request.AnimationColors) == null)
+            {
+                ModelState.AddModelError(nameof(request.AnimationColors), "Animation colors must be a non-empty array of non-empty strings");
+            }
+
+            if (request.StartDate != null && request.EndDate != null && DateTimeOffset.Compare((DateTimeOffset)request.StartDate, (DateTimeOffset)request.EndDate!) > 0)
+            {
+                ModelState.AddModelError(nameof(request.EndDate), "End date cannot be before start date");
+            }
+            
+            if (!ModelState.IsValid)
+            {
+                validationResult = this.CreateValidationError(ModelState);
+            }
+
+            return validationResult;
+        }
+
         private IActionResult? ValidateCreateAppRequest(CreateAppRequest request)
         {
             if (request is null)

BTCPayServer/Controllers/GreenField/GreenfieldInvoiceController.cs

@@ -437,6 +437,7 @@ namespace BTCPayServer.Controllers.Greenfield
                     DefaultLanguage = entity.DefaultLanguage,
                     RedirectAutomatically = entity.RedirectAutomatically,
                     RequiresRefundEmail = entity.RequiresRefundEmail,
+                    CheckoutType = entity.CheckoutType,
                     RedirectURL = entity.RedirectURLTemplate
                 },
                 Receipt = entity.ReceiptOptions

BTCPayServer/Controllers/GreenField/GreenfieldLightningNodeApiController.Internal.cs

@@ -101,6 +101,14 @@ namespace BTCPayServer.Controllers.Greenfield
             return base.GetInvoice(cryptoCode, id, cancellationToken);
         }
 
+        [Authorize(Policy = Policies.CanUseInternalLightningNode,
+            AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        [HttpGet("~/api/v1/server/lightning/{cryptoCode}/invoices")]
+        public override Task<IActionResult> GetInvoices(string cryptoCode, [FromQuery] bool? pendingOnly, [FromQuery] long? offsetIndex, CancellationToken cancellationToken = default)
+        {
+            return base.GetInvoices(cryptoCode, pendingOnly, offsetIndex, cancellationToken);
+        }
+
         [Authorize(Policy = Policies.CanUseInternalLightningNode,
             AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
         [HttpPost("~/api/v1/server/lightning/{cryptoCode}/invoices/pay")]

BTCPayServer/Controllers/GreenField/GreenfieldLightningNodeApiController.Store.cs

@@ -111,6 +111,14 @@ namespace BTCPayServer.Controllers.Greenfield
             return base.GetInvoice(cryptoCode, id, cancellationToken);
         }
 
+        [Authorize(Policy = Policies.CanUseLightningNodeInStore,
+            AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        [HttpGet("~/api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices")]
+        public override Task<IActionResult> GetInvoices(string cryptoCode, [FromQuery] bool? pendingOnly, [FromQuery] long? offsetIndex, CancellationToken cancellationToken = default)
+        {
+            return base.GetInvoices(cryptoCode, pendingOnly, offsetIndex, cancellationToken);
+        }
+
         [Authorize(Policy = Policies.CanCreateLightningInvoiceInStore,
             AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
         [HttpPost("~/api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices")]

BTCPayServer/Controllers/GreenField/GreenfieldLightningNodeApiController.cs

@@ -2,7 +2,6 @@ using System;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using BTCPayServer.Abstractions.Contracts;
 using BTCPayServer.Abstractions.Extensions;
 using BTCPayServer.Client;
 using BTCPayServer.Client.Models;
@@ -46,7 +45,14 @@ namespace BTCPayServer.Controllers.Greenfield
             return Ok(new LightningNodeInformationData
             {
                 BlockHeight = info.BlockHeight,
-                NodeURIs = info.NodeInfoList.Select(nodeInfo => nodeInfo).ToArray()
+                NodeURIs = info.NodeInfoList.Select(nodeInfo => nodeInfo).ToArray(),
+                Alias = info.Alias,
+                Color = info.Color,
+                Version = info.Version,
+                PeersCount = info.PeersCount,
+                ActiveChannelsCount = info.ActiveChannelsCount,
+                InactiveChannelsCount = info.InactiveChannelsCount,
+                PendingChannelsCount = info.PendingChannelsCount
             });
         }
 
@@ -202,9 +208,10 @@ namespace BTCPayServer.Controllers.Greenfield
         {
             var lightningClient = await GetLightningClient(cryptoCode, true);
             var network = _btcPayNetworkProvider.GetNetwork<BTCPayNetwork>(cryptoCode);
-
-            if (lightningInvoice?.BOLT11 is null ||
-                !BOLT11PaymentRequest.TryParse(lightningInvoice.BOLT11, out _, network.NBitcoinNetwork))
+            BOLT11PaymentRequest bolt11 = null;
+            
+            if (string.IsNullOrEmpty(lightningInvoice.BOLT11) ||
+                !BOLT11PaymentRequest.TryParse(lightningInvoice.BOLT11, out bolt11, network.NBitcoinNetwork))
             {
                 ModelState.AddModelError(nameof(lightningInvoice.BOLT11), "The BOLT11 invoice was invalid.");
             }
@@ -214,21 +221,54 @@ namespace BTCPayServer.Controllers.Greenfield
                 return this.CreateValidationError(ModelState);
             }
             
-            var param = lightningInvoice?.MaxFeeFlat != null || lightningInvoice?.MaxFeePercent != null || lightningInvoice?.Amount != null
-                ? new PayInvoiceParams { MaxFeePercent = lightningInvoice.MaxFeePercent, MaxFeeFlat = lightningInvoice.MaxFeeFlat, Amount = lightningInvoice.Amount }
+            var param = lightningInvoice.MaxFeeFlat != null || lightningInvoice.MaxFeePercent != null
+                    || lightningInvoice.Amount != null || lightningInvoice.SendTimeout != null
+                ? new PayInvoiceParams
+                {
+                    MaxFeePercent = lightningInvoice.MaxFeePercent,
+                    MaxFeeFlat = lightningInvoice.MaxFeeFlat,
+                    Amount = lightningInvoice.Amount,
+                    SendTimeout = lightningInvoice.SendTimeout
+                }
                 : null;
             var result = await lightningClient.Pay(lightningInvoice.BOLT11, param, cancellationToken);
             
+            if (result.Result is PayResult.Ok or PayResult.Unknown && bolt11?.PaymentHash is not null)
+            {
+                // get a new instance of the LN client, because the old one might have disposed its HTTPClient
+                lightningClient = await GetLightningClient(cryptoCode, true);
+                
+                var paymentHash = bolt11.PaymentHash.ToString();
+                var payment = await lightningClient.GetPayment(paymentHash, cancellationToken);
+                var data = new LightningPaymentData
+                {
+                    Id = payment.Id,
+                    PaymentHash = paymentHash,
+                    Status = payment.Status,
+                    BOLT11 = payment.BOLT11,
+                    Preimage = payment.Preimage,
+                    CreatedAt = payment.CreatedAt,
+                    TotalAmount = payment.AmountSent,
+                    FeeAmount = payment.Fee,
+                };
+                return result.Result is PayResult.Ok ? Ok(data) : Accepted(data);
+            }
+            
             return result.Result switch
             {
                 PayResult.CouldNotFindRoute => this.CreateAPIError("could-not-find-route", "Impossible to find a route to the peer"),
                 PayResult.Error => this.CreateAPIError("generic-error", result.ErrorDetail),
+                PayResult.Unknown => Accepted(new LightningPaymentData
+                {
+                    Status = LightningPaymentStatus.Unknown
+                }),
                 PayResult.Ok => Ok(new LightningPaymentData
                 {
+                    Status = LightningPaymentStatus.Complete,
                     TotalAmount = result.Details?.TotalAmount, 
                     FeeAmount = result.Details?.FeeAmount
                 }),
-                _ => throw new NotSupportedException("Unsupported Payresult")
+                _ => throw new NotSupportedException("Unsupported PayResult")
             };
         }
 
@@ -239,6 +279,14 @@ namespace BTCPayServer.Controllers.Greenfield
             return inv == null ? this.CreateAPIError(404, "invoice-not-found", "Impossible to find a lightning invoice with this id") : Ok(ToModel(inv));
         }
 
+        public virtual async Task<IActionResult> GetInvoices(string cryptoCode, [FromQuery] bool? pendingOnly, [FromQuery] long? offsetIndex, CancellationToken cancellationToken = default)
+        {
+            var lightningClient = await GetLightningClient(cryptoCode, false);
+            var param = new ListInvoicesParams { PendingOnly = pendingOnly, OffsetIndex = offsetIndex };
+            var invoices = await lightningClient.ListInvoices(param, cancellationToken);
+            return Ok(invoices.Select(ToModel));
+        }
+
         public virtual async Task<IActionResult> CreateInvoice(string cryptoCode, CreateLightningInvoiceRequest request, CancellationToken cancellationToken = default)
         {
             var lightningClient = await GetLightningClient(cryptoCode, false);
@@ -296,7 +344,7 @@ namespace BTCPayServer.Controllers.Greenfield
 
         private LightningInvoiceData ToModel(LightningInvoice invoice)
         {
-            return new LightningInvoiceData
+            var data = new LightningInvoiceData
             {
                 Amount = invoice.Amount,
                 Id = invoice.Id,
@@ -306,6 +354,12 @@ namespace BTCPayServer.Controllers.Greenfield
                 BOLT11 = invoice.BOLT11,
                 ExpiresAt = invoice.ExpiresAt
             };
+
+            if (invoice.CustomRecords != null)
+            {
+                data.CustomRecords = invoice.CustomRecords;
+            }
+            return data;
         }
 
         private LightningPaymentData ToModel(LightningPayment payment)

BTCPayServer/Controllers/GreenField/GreenfieldPaymentRequestsController.cs

@@ -1,18 +1,22 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Abstractions.Constants;
 using BTCPayServer.Abstractions.Extensions;
 using BTCPayServer.Client;
 using BTCPayServer.Client.Models;
 using BTCPayServer.Data;
+using BTCPayServer.PaymentRequest;
 using BTCPayServer.Security;
+using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.PaymentRequests;
 using BTCPayServer.Services.Rates;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
 using PaymentRequestData = BTCPayServer.Data.PaymentRequestData;
 
 namespace BTCPayServer.Controllers.Greenfield
@@ -22,14 +26,26 @@ namespace BTCPayServer.Controllers.Greenfield
     [EnableCors(CorsPolicies.All)]
     public class GreenfieldPaymentRequestsController : ControllerBase
     {
+        private readonly InvoiceRepository _InvoiceRepository;
+        private readonly UIInvoiceController _invoiceController;
         private readonly PaymentRequestRepository _paymentRequestRepository;
         private readonly CurrencyNameTable _currencyNameTable;
+        private readonly LinkGenerator _linkGenerator;
 
-        public GreenfieldPaymentRequestsController(PaymentRequestRepository paymentRequestRepository,
-            CurrencyNameTable currencyNameTable)
+        public GreenfieldPaymentRequestsController(
+            InvoiceRepository invoiceRepository,
+            UIInvoiceController invoiceController,
+            PaymentRequestRepository paymentRequestRepository,
+            PaymentRequestService paymentRequestService,
+            CurrencyNameTable currencyNameTable,
+            LinkGenerator linkGenerator)
         {
+            _InvoiceRepository = invoiceRepository;
+            _invoiceController = invoiceController;
             _paymentRequestRepository = paymentRequestRepository;
+            PaymentRequestService = paymentRequestService;
             _currencyNameTable = currencyNameTable;
+            _linkGenerator = linkGenerator;
         }
 
         [Authorize(Policy = Policies.CanViewPaymentRequests, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
@@ -56,6 +72,62 @@ namespace BTCPayServer.Controllers.Greenfield
             return Ok(FromModel(pr.First()));
         }
 
+        [Authorize(Policy = Policies.CanViewPaymentRequests, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        [HttpPost("~/api/v1/stores/{storeId}/payment-requests/{paymentRequestId}/pay")]
+        public async Task<IActionResult> PayPaymentRequest(string storeId, string paymentRequestId, [FromBody] PayPaymentRequestRequest pay, CancellationToken cancellationToken)
+        {
+            var pr = await this.PaymentRequestService.GetPaymentRequest(paymentRequestId);
+            if (pr is null || pr.StoreId != storeId)
+                return PaymentRequestNotFound();
+
+            var amount = pay?.Amount;
+            if (amount.HasValue && amount.Value <= 0)
+            {
+                ModelState.AddModelError(nameof(pay.Amount), "The amount should be more than 0");
+            }
+            if (amount.HasValue && !pr.AllowCustomPaymentAmounts && amount.Value != pr.AmountDue)
+            {
+                ModelState.AddModelError(nameof(pay.Amount), "This payment request doesn't allow custom payment amount");
+            }
+
+            if (!ModelState.IsValid)
+                return this.CreateValidationError(ModelState);
+
+            if (pr.Archived)
+            {
+                return this.CreateAPIError("archived", "You cannot pay an archived payment request");
+            }
+
+            if (pr.AmountDue <= 0)
+            {
+                return this.CreateAPIError("already-paid", "This payment request is already paid");
+            }
+
+            if (pr.ExpiryDate.HasValue && DateTime.UtcNow >= pr.ExpiryDate)
+            {
+                return this.CreateAPIError("expired", "This payment request is expired");
+            }
+
+            if (pay?.AllowPendingInvoiceReuse is true)
+            {
+                if (pr.Invoices.GetReusableInvoice(amount)?.Id is string invoiceId)
+                {
+                    var inv = await _InvoiceRepository.GetInvoice(invoiceId);
+                    return Ok(GreenfieldInvoiceController.ToModel(inv, _linkGenerator, Request));
+                }
+            }
+
+            try
+            {
+                var invoice = await _invoiceController.CreatePaymentRequestInvoice(pr, amount, this.StoreData, Request, cancellationToken);
+                return Ok(GreenfieldInvoiceController.ToModel(invoice, _linkGenerator, Request));
+            }
+            catch (BitpayHttpException e)
+            {
+                return this.CreateAPIError(null, e.Message);
+            }
+        }
+
         [Authorize(Policy = Policies.CanModifyPaymentRequests,
             AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
         [HttpDelete("~/api/v1/stores/{storeId}/payment-requests/{paymentRequestId}")]
@@ -97,6 +169,9 @@ namespace BTCPayServer.Controllers.Greenfield
             return Ok(FromModel(pr));
         }
         public Data.StoreData StoreData => HttpContext.GetStoreData();
+
+        public PaymentRequestService PaymentRequestService { get; }
+
         [HttpPut("~/api/v1/stores/{storeId}/payment-requests/{paymentRequestId}")]
         [Authorize(Policy = Policies.CanModifyPaymentRequests,
             AuthenticationSchemes = AuthenticationSchemes.Greenfield)]

BTCPayServer/Controllers/GreenField/GreenfieldPullPaymentController.cs

@@ -18,6 +18,7 @@ using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.EntityFrameworkCore;
+using MarkPayoutRequest = BTCPayServer.HostedServices.MarkPayoutRequest;
 
 namespace BTCPayServer.Controllers.Greenfield
 {
@@ -243,12 +244,13 @@ namespace BTCPayServer.Controllers.Greenfield
             model.Destination = blob.Destination;
             model.PaymentMethod = p.PaymentMethodId;
             model.CryptoCode = p.GetPaymentMethodId().CryptoCode;
+            model.PaymentProof = p.GetProofBlobJson();
             return model;
         }
 
         [HttpPost("~/api/v1/pull-payments/{pullPaymentId}/payouts")]
         [AllowAnonymous]
-        public async Task<IActionResult> CreatePayout(string pullPaymentId, CreatePayoutRequest request)
+        public async Task<IActionResult> CreatePayout(string pullPaymentId, CreatePayoutRequest request, CancellationToken cancellationToken)
         {
             if (!PaymentMethodId.TryParse(request?.PaymentMethod, out var paymentMethodId))
             {
@@ -268,7 +270,7 @@ namespace BTCPayServer.Controllers.Greenfield
             if (pp is null)
                 return PullPaymentNotFound();
             var ppBlob = pp.GetBlob();
-            var destination = await payoutHandler.ParseAndValidateClaimDestination(paymentMethodId, request!.Destination, ppBlob);
+            var destination = await payoutHandler.ParseAndValidateClaimDestination(paymentMethodId, request!.Destination, ppBlob, cancellationToken);
             if (destination.destination is null)
             {
                 ModelState.AddModelError(nameof(request.Destination), destination.error ?? "The destination is invalid for the payment specified");
@@ -330,7 +332,7 @@ namespace BTCPayServer.Controllers.Greenfield
                     return PullPaymentNotFound();
                 ppBlob = pp.GetBlob();
             }
-            var destination = await payoutHandler.ParseAndValidateClaimDestination(paymentMethodId, request!.Destination, ppBlob);
+            var destination = await payoutHandler.ParseAndValidateClaimDestination(paymentMethodId, request!.Destination, ppBlob, default);
             if (destination.destination is null)
             {
                 ModelState.AddModelError(nameof(request.Destination), destination.error ?? "The destination is invalid for the payment specified");
@@ -417,19 +419,15 @@ namespace BTCPayServer.Controllers.Greenfield
             
             
             return base.Ok(payouts
-                .Select(ToModel).ToList());
+                .Select(ToModel).ToArray());
         }
 
         [HttpDelete("~/api/v1/stores/{storeId}/payouts/{payoutId}")]
         [Authorize(Policy = Policies.CanManagePullPayments, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
         public async Task<IActionResult> CancelPayout(string storeId, string payoutId)
         {
-            using var ctx = _dbContextFactory.CreateContext();
-            var payout = await ctx.Payouts.GetPayout(payoutId, storeId);
-            if (payout is null)
-                return PayoutNotFound();
-            await _pullPaymentService.Cancel(new PullPaymentHostedService.CancelRequest(new[] { payoutId }));
-            return Ok();
+            var res=  await _pullPaymentService.Cancel(new PullPaymentHostedService.CancelRequest(new[] { payoutId }, new []{storeId}));
+            return MapResult(res.First().Value);
         }
 
         [HttpPost("~/api/v1/stores/{storeId}/payouts/{payoutId}")]
@@ -490,29 +488,67 @@ namespace BTCPayServer.Controllers.Greenfield
         [Authorize(Policy = Policies.CanManagePullPayments, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
         public async Task<IActionResult> MarkPayoutPaid(string storeId, string payoutId, CancellationToken cancellationToken = default)
         {
+            return await MarkPayout(storeId, payoutId, new Client.Models.MarkPayoutRequest()
+            {
+                State = PayoutState.Completed,
+                PaymentProof = null
+            });
+        }
+
+        [HttpPost("~/api/v1/stores/{storeId}/payouts/{payoutId}/mark")]
+        [Authorize(Policy = Policies.CanManagePullPayments, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> MarkPayout(string storeId, string payoutId, Client.Models.MarkPayoutRequest request)
+        {
+            request ??= new();
+
+            if (request.State == PayoutState.Cancelled)
+            {
+                return await CancelPayout(storeId, payoutId);
+            }
+            if (request.PaymentProof is not null &&
+                !BitcoinLikePayoutHandler.TryParseProofType(request.PaymentProof, out string _))
+            {
+                ModelState.AddModelError(nameof(request.PaymentProof), "Payment proof must have a 'proofType' property");
+            }
             if (!ModelState.IsValid)
                 return this.CreateValidationError(ModelState);
 
-            var result = await _pullPaymentService.MarkPaid(new PayoutPaidRequest()
+            var result = await _pullPaymentService.MarkPaid(new MarkPayoutRequest()
             {
-                //TODO: Allow API to specify the manual proof object
-                Proof = null,
-                PayoutId = payoutId
+                Proof = request.PaymentProof,
+                PayoutId = payoutId,
+                State = request.State
             });
-            var errorMessage = PayoutPaidRequest.GetErrorMessage(result);
-            switch (result)
-            {
-                case PayoutPaidRequest.PayoutPaidResult.Ok:
-                    return Ok();
-                case PayoutPaidRequest.PayoutPaidResult.InvalidState:
-                    return this.CreateAPIError("invalid-state", errorMessage);
-                case PayoutPaidRequest.PayoutPaidResult.NotFound:
-                    return PayoutNotFound();
-                default:
-                    throw new NotSupportedException();
-            }
+            return MapResult(result);
         }
 
+        [HttpGet("~/api/v1/stores/{storeId}/payouts/{payoutId}")]
+        [Authorize(Policy = Policies.CanManagePullPayments, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> GetStorePayout(string storeId, string payoutId)
+        {
+            await using var ctx = _dbContextFactory.CreateContext();
+
+            var payout = (await _pullPaymentService.GetPayouts(new PullPaymentHostedService.PayoutQuery()
+            {
+                Stores = new[] {storeId}, PayoutIds = new[] {payoutId}
+            })).FirstOrDefault();
+
+            if (payout is null)
+                return PayoutNotFound();
+            return base.Ok(ToModel(payout));
+        }
+        
+        private IActionResult MapResult(MarkPayoutRequest.PayoutPaidResult result)
+        {
+            var errorMessage = MarkPayoutRequest.GetErrorMessage(result);
+            return result switch
+            {
+                MarkPayoutRequest.PayoutPaidResult.Ok => Ok(),
+                MarkPayoutRequest.PayoutPaidResult.InvalidState => this.CreateAPIError("invalid-state", errorMessage),
+                MarkPayoutRequest.PayoutPaidResult.NotFound => PayoutNotFound(),
+                _ => throw new NotSupportedException()
+            };
+        }
         private IActionResult PayoutNotFound()
         {
             return this.CreateAPIError(404, "payout-not-found", "The payout was not found");

BTCPayServer/Controllers/GreenField/GreenfieldStoreLightningNetworkPaymentMethodsController.cs

@@ -35,7 +35,6 @@ namespace BTCPayServer.Controllers.Greenfield
         private readonly StoreRepository _storeRepository;
         private readonly BTCPayNetworkProvider _btcPayNetworkProvider;
         private readonly IAuthorizationService _authorizationService;
-        private readonly ISettingsRepository _settingsRepository;
 
         public GreenfieldStoreLightningNetworkPaymentMethodsController(
             StoreRepository storeRepository,
@@ -47,7 +46,6 @@ namespace BTCPayServer.Controllers.Greenfield
             _storeRepository = storeRepository;
             _btcPayNetworkProvider = btcPayNetworkProvider;
             _authorizationService = authorizationService;
-            _settingsRepository = settingsRepository;
             PoliciesSettings = policiesSettings;
         }
 

BTCPayServer/Controllers/GreenField/GreenfieldStoreOnChainWalletsController.cs

@@ -28,6 +28,7 @@ using NBXplorer;
 using NBXplorer.Models;
 using Newtonsoft.Json.Linq;
 using StoreData = BTCPayServer.Data.StoreData;
+using Microsoft.EntityFrameworkCore;
 
 namespace BTCPayServer.Controllers.Greenfield
 {
@@ -52,7 +53,6 @@ namespace BTCPayServer.Controllers.Greenfield
         private readonly EventAggregator _eventAggregator;
         private readonly WalletReceiveService _walletReceiveService;
         private readonly IFeeProviderFactory _feeProviderFactory;
-        private readonly LabelFactory _labelFactory;
         private readonly UTXOLocker _utxoLocker;
 
         public GreenfieldStoreOnChainWalletsController(
@@ -69,7 +69,6 @@ namespace BTCPayServer.Controllers.Greenfield
             EventAggregator eventAggregator,
             WalletReceiveService walletReceiveService,
             IFeeProviderFactory feeProviderFactory,
-            LabelFactory labelFactory,
             UTXOLocker utxoLocker
         )
         {
@@ -86,7 +85,6 @@ namespace BTCPayServer.Controllers.Greenfield
             _eventAggregator = eventAggregator;
             _walletReceiveService = walletReceiveService;
             _feeProviderFactory = feeProviderFactory;
-            _labelFactory = labelFactory;
             _utxoLocker = utxoLocker;
         }
 
@@ -95,7 +93,7 @@ namespace BTCPayServer.Controllers.Greenfield
         public async Task<IActionResult> ShowOnChainWalletOverview(string storeId, string cryptoCode)
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
 
             var wallet = _btcPayWalletProvider.GetWallet(network);
@@ -115,7 +113,7 @@ namespace BTCPayServer.Controllers.Greenfield
         public async Task<IActionResult> GetOnChainFeeRate(string storeId, string cryptoCode, int? blockTarget = null)
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
 
             var feeRateTarget = blockTarget ?? Store.GetStoreBlob().RecommendedFeeBlockTarget;
@@ -128,10 +126,11 @@ namespace BTCPayServer.Controllers.Greenfield
 
         [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
         [HttpGet("~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address")]
-        public async Task<IActionResult> GetOnChainWalletReceiveAddress(string storeId, string cryptoCode, bool forceGenerate = false)
+        public async Task<IActionResult> GetOnChainWalletReceiveAddress(string storeId, string cryptoCode,
+            bool forceGenerate = false)
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
 
             var kpi = await _walletReceiveService.GetOrGenerate(new WalletId(storeId, cryptoCode), forceGenerate);
@@ -144,13 +143,14 @@ namespace BTCPayServer.Controllers.Greenfield
             var allowedPayjoin = derivationScheme.IsHotWallet && Store.GetStoreBlob().PayJoinEnabled;
             if (allowedPayjoin)
             {
-                bip21.QueryParams.Add(PayjoinClient.BIP21EndpointKey, Request.GetAbsoluteUri(Url.Action(nameof(PayJoinEndpointController.Submit), "PayJoinEndpoint", new { cryptoCode })));
+                bip21.QueryParams.Add(PayjoinClient.BIP21EndpointKey,
+                    Request.GetAbsoluteUri(Url.Action(nameof(PayJoinEndpointController.Submit), "PayJoinEndpoint",
+                        new {cryptoCode})));
             }
+
             return Ok(new OnChainWalletAddressData()
             {
-                Address = kpi.Address?.ToString(),
-                PaymentLink = bip21.ToString(),
-                KeyPath = kpi.KeyPath
+                Address = kpi.Address?.ToString(), PaymentLink = bip21.ToString(), KeyPath = kpi.KeyPath
             });
         }
 
@@ -159,7 +159,7 @@ namespace BTCPayServer.Controllers.Greenfield
         public async Task<IActionResult> UnReserveOnChainWalletReceiveAddress(string storeId, string cryptoCode)
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
 
             var addr = await _walletReceiveService.UnReserveAddress(new WalletId(storeId, cryptoCode));
@@ -168,6 +168,7 @@ namespace BTCPayServer.Controllers.Greenfield
                 return this.CreateAPIError("no-reserved-address",
                     $"There was no reserved address for {cryptoCode} on this store.");
             }
+
             return Ok();
         }
 
@@ -183,7 +184,7 @@ namespace BTCPayServer.Controllers.Greenfield
         )
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
 
             var wallet = _btcPayWalletProvider.GetWallet(network);
@@ -193,7 +194,8 @@ namespace BTCPayServer.Controllers.Greenfield
             var preFiltering = true;
             if (statusFilter?.Any() is true || !string.IsNullOrWhiteSpace(labelFilter))
                 preFiltering = false;
-            var txs = await wallet.FetchTransactionHistory(derivationScheme.AccountDerivation, preFiltering ? skip : 0, preFiltering ? limit : int.MaxValue);
+            var txs = await wallet.FetchTransactionHistory(derivationScheme.AccountDerivation, preFiltering ? skip : 0,
+                preFiltering ? limit : int.MaxValue);
             if (!preFiltering)
             {
                 var filteredList = new List<TransactionHistoryLine>(txs.Count);
@@ -202,9 +204,10 @@ namespace BTCPayServer.Controllers.Greenfield
                     if (!string.IsNullOrWhiteSpace(labelFilter))
                     {
                         walletTransactionsInfoAsync.TryGetValue(t.TransactionId.ToString(), out var transactionInfo);
-                        if (transactionInfo?.Labels.ContainsKey(labelFilter) is true)
+                        if (transactionInfo?.LabelColors.ContainsKey(labelFilter) is true)
                             filteredList.Add(t);
                     }
+
                     if (statusFilter?.Any() is true)
                     {
                         if (statusFilter.Contains(TransactionStatus.Confirmed) && t.Confirmations != 0)
@@ -213,6 +216,7 @@ namespace BTCPayServer.Controllers.Greenfield
                             filteredList.Add(t);
                     }
                 }
+
                 txs = filteredList;
             }
 
@@ -230,7 +234,7 @@ namespace BTCPayServer.Controllers.Greenfield
             string transactionId)
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
 
             var wallet = _btcPayWalletProvider.GetWallet(network);
@@ -242,16 +246,17 @@ namespace BTCPayServer.Controllers.Greenfield
 
             var walletId = new WalletId(storeId, cryptoCode);
             var walletTransactionsInfoAsync =
-                (await _walletRepository.GetWalletTransactionsInfo(walletId, new[] { transactionId })).Values
+                (await _walletRepository.GetWalletTransactionsInfo(walletId, new[] {transactionId})).Values
                 .FirstOrDefault();
 
             return Ok(ToModel(walletTransactionsInfoAsync, tx, wallet));
         }
 
         [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
-        [HttpPatch("~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}")]
+        [HttpPatch(
+            "~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}")]
         public async Task<IActionResult> PatchOnChainWalletTransaction(
-            string storeId, 
+            string storeId,
             string cryptoCode,
             string transactionId,
             [FromBody] PatchOnChainTransactionRequest request,
@@ -259,7 +264,7 @@ namespace BTCPayServer.Controllers.Greenfield
         )
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
 
             var wallet = _btcPayWalletProvider.GetWallet(network);
@@ -270,38 +275,20 @@ namespace BTCPayServer.Controllers.Greenfield
             }
 
             var walletId = new WalletId(storeId, cryptoCode);
-            var walletTransactionsInfoAsync = _walletRepository.GetWalletTransactionsInfo(walletId);
-            if (!(await walletTransactionsInfoAsync).TryGetValue(transactionId, out var walletTransactionInfo))
-            {
-                walletTransactionInfo = new WalletTransactionInfo();
-            }
+            var txObjectId = new WalletObjectId(walletId, WalletObjectData.Types.Tx, transactionId);
 
             if (request.Comment != null)
             {
-                walletTransactionInfo.Comment = request.Comment.Trim().Truncate(WalletTransactionDataExtensions.MaxCommentSize);
+                await _walletRepository.SetWalletObjectComment(txObjectId, request.Comment);
             }
 
             if (request.Labels != null)
             {
-                var walletBlobInfo = await _walletRepository.GetWalletInfo(walletId);
-                
-                foreach (string label in request.Labels)
-                {
-                    var rawLabel = await _labelFactory.BuildLabel(
-                        walletBlobInfo,
-                        Request,
-                        walletTransactionInfo,
-                        walletId,
-                        transactionId,
-                        label
-                    );
-                    walletTransactionInfo.Labels.TryAdd(rawLabel.Text, rawLabel);
-                }
+                await _walletRepository.AddWalletObjectLabels(txObjectId, request.Labels.ToArray());
             }
 
-            await _walletRepository.SetWalletTransactionInfo(walletId, transactionId, walletTransactionInfo);
             var walletTransactionsInfo =
-                (await _walletRepository.GetWalletTransactionsInfo(walletId, new[] { transactionId }))
+                (await _walletRepository.GetWalletTransactionsInfo(walletId, new[] {transactionId}))
                 .Values
                 .FirstOrDefault();
 
@@ -313,31 +300,35 @@ namespace BTCPayServer.Controllers.Greenfield
         public async Task<IActionResult> GetOnChainWalletUTXOs(string storeId, string cryptoCode)
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
 
             var wallet = _btcPayWalletProvider.GetWallet(network);
 
             var walletId = new WalletId(storeId, cryptoCode);
-            var walletTransactionsInfoAsync = await _walletRepository.GetWalletTransactionsInfo(walletId);
             var utxos = await wallet.GetUnspentCoins(derivationScheme.AccountDerivation);
-            
+            var walletTransactionsInfoAsync = await _walletRepository.GetWalletTransactionsInfo(walletId,
+                utxos.Select(u => u.OutPoint.Hash.ToString()).ToHashSet().ToArray());
             return Ok(utxos.Select(coin =>
                 {
                     walletTransactionsInfoAsync.TryGetValue(coin.OutPoint.Hash.ToString(), out var info);
-                    var labels = info?.Labels ?? new Dictionary<string, LabelData>();
+
                     return new OnChainWalletUTXOData()
                     {
                         Outpoint = coin.OutPoint,
                         Amount = coin.Value.GetValue(network),
                         Comment = info?.Comment,
-                        Labels = info?.Labels,
+#pragma warning disable CS0612 // Type or member is obsolete
+                        Labels = info?.LegacyLabels ?? new Dictionary<string, LabelData>(),
+#pragma warning restore CS0612 // Type or member is obsolete
                         Link = string.Format(CultureInfo.InvariantCulture, network.BlockExplorerLink,
                             coin.OutPoint.Hash.ToString()),
                         Timestamp = coin.Timestamp,
                         KeyPath = coin.KeyPath,
                         Confirmations = coin.Confirmations,
-                        Address = network.NBXplorerNetwork.CreateAddress(derivationScheme.AccountDerivation, coin.KeyPath, coin.ScriptPubKey).ToString()
+                        Address = network.NBXplorerNetwork
+                            .CreateAddress(derivationScheme.AccountDerivation, coin.KeyPath, coin.ScriptPubKey)
+                            .ToString()
                     };
                 }).ToList()
             );
@@ -349,7 +340,7 @@ namespace BTCPayServer.Controllers.Greenfield
             [FromBody] CreateOnChainTransactionRequest request)
         {
             if (IsInvalidWalletRequest(cryptoCode, out var network,
-                out var derivationScheme, out var actionResult))
+                    out var derivationScheme, out var actionResult))
                 return actionResult;
             if (network.ReadonlyWallet)
             {
@@ -360,7 +351,8 @@ namespace BTCPayServer.Controllers.Greenfield
             //This API is only meant for hot wallet usage for now. We can expand later when we allow PSBT manipulation.
             if (!(await CanUseHotWallet()).HotWallet)
             {
-                return this.CreateAPIError(503, "not-available", $"You need to allow non-admins to use hotwallets for their stores (in /server/policies)");
+                return this.CreateAPIError(503, "not-available",
+                    $"You need to allow non-admins to use hotwallets for their stores (in /server/policies)");
             }
 
             if (request.Destinations == null || !request.Destinations.Any())
@@ -421,6 +413,7 @@ namespace BTCPayServer.Controllers.Greenfield
                 {
                     amount = null;
                 }
+
                 var address = string.Empty;
                 try
                 {
@@ -453,9 +446,12 @@ namespace BTCPayServer.Controllers.Greenfield
                 if (amount is null || amount <= 0)
                 {
                     request.AddModelError(transactionRequest => transactionRequest.Destinations[index],
-                        "Amount must be specified or destination must be a BIP21 payment link, and greater than 0", this);
+                        "Amount must be specified or destination must be a BIP21 payment link, and greater than 0",
+                        this);
                 }
-                if (request.ProceedWithPayjoin && bip21?.UnknownParameters?.ContainsKey(PayjoinClient.BIP21EndpointKey) is true)
+
+                if (request.ProceedWithPayjoin &&
+                    bip21?.UnknownParameters?.ContainsKey(PayjoinClient.BIP21EndpointKey) is true)
                 {
                     payjoinOutputIndex = index;
                 }
@@ -585,15 +581,17 @@ namespace BTCPayServer.Controllers.Greenfield
                     await _delayedTransactionBroadcaster.Schedule(DateTimeOffset.UtcNow + TimeSpan.FromMinutes(2.0),
                         transaction, network);
                     var payjoinPSBT = await _payjoinClient.RequestPayjoin(
-                        new BitcoinUrlBuilder(signingContext.PayJoinBIP21, network.NBitcoinNetwork), new PayjoinWallet(derivationScheme),
+                        new BitcoinUrlBuilder(signingContext.PayJoinBIP21, network.NBitcoinNetwork),
+                        new PayjoinWallet(derivationScheme),
                         psbt.PSBT, CancellationToken.None);
-                    psbt.PSBT.Settings.SigningOptions = new SigningOptions() { EnforceLowR = !(signingContext?.EnforceLowR is false) };
+                    psbt.PSBT.Settings.SigningOptions =
+                        new SigningOptions() {EnforceLowR = !(signingContext?.EnforceLowR is false)};
                     payjoinPSBT = psbt.PSBT.SignAll(derivationScheme.AccountDerivation, accountKey, rootedKeyPath);
                     payjoinPSBT.Finalize();
                     var payjoinTransaction = payjoinPSBT.ExtractTransaction();
                     var hash = payjoinTransaction.GetHash();
-                    _eventAggregator.Publish(new UpdateTransactionLabel(new WalletId(Store.Id, cryptoCode), hash,
-                        UpdateTransactionLabel.PayjoinLabelTemplate()));
+                    await this._walletRepository.AddWalletTransactionAttachment(new WalletId(Store.Id, cryptoCode),
+                        hash, Attachment.Payjoin());
                     broadcastResult = await explorerClient.BroadcastAsync(payjoinTransaction);
                     if (broadcastResult.Success)
                     {
@@ -622,19 +620,156 @@ namespace BTCPayServer.Controllers.Greenfield
             }
         }
 
+        [HttpGet("~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> GetOnChainWalletObjects(string storeId, string cryptoCode, string? type = null, [FromQuery(Name = "ids")] string[]? ids = null, bool? includeNeighbourData = null)
+        {
+            if (ids?.Length is 0 && !Request.Query.ContainsKey("ids"))
+                ids = null;
+            if (type is null && ids is not null)
+                ModelState.AddModelError(nameof(ids), "If ids is specified, type should be specified");
+            if (!ModelState.IsValid)
+                return this.CreateValidationError(ModelState);
+            var walletId = new WalletId(storeId, cryptoCode);
+            return Ok((await _walletRepository.GetWalletObjects(new(walletId, type, ids) { IncludeNeighbours = includeNeighbourData ?? true })).Select(kv => kv.Value).Select(ToModel).ToArray());
+        }
+        [HttpGet("~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectType}/{objectId}")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> GetOnChainWalletObject(string storeId, string cryptoCode,
+            string objectType, string objectId,
+            bool? includeNeighbourData = null)
+        {
+            var walletId = new WalletId(storeId, cryptoCode);
+            var wo = await _walletRepository.GetWalletObject(new(walletId, objectType, objectId), includeNeighbourData ?? true);
+            if (wo is null)
+                return WalletObjectNotFound();
+            return Ok(ToModel(wo));
+        }
+
+        [HttpDelete("~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectType}/{objectId}")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> RemoveOnChainWalletObject(string storeId, string cryptoCode,
+            string objectType, string objectId)
+        {
+            var walletId = new WalletId(storeId, cryptoCode);
+            if (await _walletRepository.RemoveWalletObjects(new WalletObjectId(walletId, objectType, objectId)))
+                return Ok();
+            else
+                return WalletObjectNotFound();
+        }
+
+        private IActionResult WalletObjectNotFound()
+        {
+            return this.CreateAPIError(404, "wallet-object-not-found", "This wallet object's can't be found");
+        }
+
+        [HttpPost("~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> AddOrUpdateOnChainWalletObject(string storeId, string cryptoCode,
+            [FromBody] AddOnChainWalletObjectRequest request)
+        {
+            if (request?.Type is null)
+                ModelState.AddModelError(nameof(request.Type), "Type is required");
+            if (request?.Id is null)
+                ModelState.AddModelError(nameof(request.Id), "Id is required");
+            if (!ModelState.IsValid)
+                return this.CreateValidationError(ModelState);
+
+            var walletId = new WalletId(storeId, cryptoCode);
+
+            try
+            {
+                await _walletRepository.SetWalletObject(
+                        new WalletObjectId(walletId, request!.Type, request.Id), request.Data);
+                return await GetOnChainWalletObject(storeId, cryptoCode, request!.Type, request.Id);
+            }
+            catch (DbUpdateException)
+            {
+                return WalletObjectNotFound();
+            }
+        }
+
+        [HttpPost("~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectType}/{objectId}/links")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> AddOrUpdateOnChainWalletLinks(string storeId, string cryptoCode,
+            string objectType, string objectId,
+            [FromBody] AddOnChainWalletObjectLinkRequest request)
+        {
+            if (request?.Type is null)
+                ModelState.AddModelError(nameof(request.Type), "Type is required");
+            if (request?.Id is null)
+                ModelState.AddModelError(nameof(request.Id), "Id is required");
+            if (!ModelState.IsValid)
+                return this.CreateValidationError(ModelState);
+
+            var walletId = new WalletId(storeId, cryptoCode);
+            try
+            {
+                await _walletRepository.SetWalletObjectLink(
+                        new WalletObjectId(walletId, objectType, objectId),
+                        new WalletObjectId(walletId, request!.Type, request.Id),
+                        request?.Data);
+                return Ok();
+            }
+            catch (DbUpdateException)
+            {
+                return WalletObjectNotFound();
+            }
+        }
+
+        [HttpDelete("~/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectType}/{objectId}/links/{linkType}/{linkId}")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> RemoveOnChainWalletLink(string storeId, string cryptoCode,
+            string objectType, string objectId,
+            string linkType, string linkId)
+        {
+            var walletId = new WalletId(storeId, cryptoCode);
+            if (await _walletRepository.RemoveWalletObjectLink(
+                    new WalletObjectId(walletId, objectType, objectId),
+                    new WalletObjectId(walletId, linkType, linkId)))
+                return Ok();
+            else
+                return WalletObjectNotFound();
+        }
+
+        private OnChainWalletObjectData ToModel(WalletObjectData data)
+        {
+            return new OnChainWalletObjectData()
+            {
+                Data = string.IsNullOrEmpty(data.Data) ? null : JObject.Parse(data.Data),
+                Type = data.Type,
+                Id = data.Id,
+                Links = data.GetLinks().Select(linkData => ToModel(linkData)).ToArray()
+            };
+        }
+
+        private OnChainWalletObjectData.OnChainWalletObjectLink ToModel((string type, string id, string linkdata, string objectdata) data)
+        {
+            return new OnChainWalletObjectData.OnChainWalletObjectLink()
+            {
+                LinkData = string.IsNullOrEmpty(data.linkdata) ? null : JObject.Parse(data.linkdata),
+                ObjectData = string.IsNullOrEmpty(data.objectdata) ? null : JObject.Parse(data.objectdata),
+                Type = data.type,
+                Id = data.id,
+            };
+        }
+
+
         private async Task<(bool HotWallet, bool RPCImport)> CanUseHotWallet()
         {
             return await _authorizationService.CanUseHotWallet(PoliciesSettings, User);
         }
 
         private bool IsInvalidWalletRequest(string cryptoCode, [MaybeNullWhen(true)] out BTCPayNetwork network,
-            [MaybeNullWhen(true)] out DerivationSchemeSettings derivationScheme, [MaybeNullWhen(false)] out IActionResult actionResult)
+            [MaybeNullWhen(true)] out DerivationSchemeSettings derivationScheme,
+            [MaybeNullWhen(false)] out IActionResult actionResult)
         {
             derivationScheme = null;
             network = _btcPayNetworkProvider.GetNetwork<BTCPayNetwork>(cryptoCode);
             if (network is null)
             {
-                throw new JsonHttpException(this.CreateAPIError(404, "unknown-cryptocode", "This crypto code isn't set up in this BTCPay Server instance"));
+                throw new JsonHttpException(this.CreateAPIError(404, "unknown-cryptocode",
+                    "This crypto code isn't set up in this BTCPay Server instance"));
             }
 
 
@@ -676,7 +811,9 @@ namespace BTCPayServer.Controllers.Greenfield
             {
                 TransactionHash = tx.TransactionId,
                 Comment = walletTransactionsInfoAsync?.Comment ?? string.Empty,
-                Labels = walletTransactionsInfoAsync?.Labels ?? new Dictionary<string, LabelData>(),
+#pragma warning disable CS0612 // Type or member is obsolete
+                Labels = walletTransactionsInfoAsync?.LegacyLabels ?? new Dictionary<string, LabelData>(),
+#pragma warning restore CS0612 // Type or member is obsolete
                 Amount = tx.BalanceChange.GetValue(wallet.Network),
                 BlockHash = tx.BlockHash,
                 BlockHeight = tx.Height,

BTCPayServer/Controllers/GreenField/GreenfieldStoreRatesConfigurationController.cs

@@ -0,0 +1,204 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Constants;
+using BTCPayServer.Abstractions.Extensions;
+using BTCPayServer.Client;
+using BTCPayServer.Client.Models;
+using BTCPayServer.Data;
+using BTCPayServer.Rating;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using RateSource = BTCPayServer.Client.Models.RateSource;
+
+namespace BTCPayServer.Controllers.GreenField
+{
+    [ApiController]
+    [Route("api/v1/stores/{storeId}/rates/configuration")]
+    [Authorize(AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+    public class GreenfieldStoreRateConfigurationController : ControllerBase
+    {
+        private readonly RateFetcher _rateProviderFactory;
+        private readonly BTCPayNetworkProvider _btcPayNetworkProvider;
+        private readonly StoreRepository _storeRepository;
+
+        public GreenfieldStoreRateConfigurationController(
+            RateFetcher rateProviderFactory,
+            BTCPayNetworkProvider btcPayNetworkProvider,
+            StoreRepository storeRepository)
+        {
+            _rateProviderFactory = rateProviderFactory;
+            _btcPayNetworkProvider = btcPayNetworkProvider;
+            _storeRepository = storeRepository;
+        }
+
+        [HttpGet("")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public IActionResult GetStoreRateConfiguration()
+        {
+            var data = HttpContext.GetStoreData();
+            var blob = data.GetStoreBlob();
+
+            return Ok(new StoreRateConfiguration()
+            {
+                EffectiveScript = blob.GetRateRules(_btcPayNetworkProvider, out var preferredExchange).ToString(),
+                Spread = blob.Spread * 100.0m,
+                IsCustomScript = blob.RateScripting,
+                PreferredSource = preferredExchange ? blob.PreferredExchange : null
+            });
+        }
+
+        [HttpGet("/misc/rate-sources")]
+        [Authorize(AuthenticationSchemes = AuthenticationSchemes.Cookie + "," + AuthenticationSchemes.Greenfield)]
+        public ActionResult<List<RateSource>> GetRateSources()
+        {
+            return Ok(_rateProviderFactory.RateProviderFactory.GetSupportedExchanges().Select(provider =>
+                new RateSource() {Id = provider.Id, Name = provider.DisplayName}));
+        }
+
+        [HttpPut("")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> UpdateStoreRateConfiguration(
+            StoreRateConfiguration configuration)
+        {
+            var storeData = HttpContext.GetStoreData();
+            var blob = storeData.GetStoreBlob();
+            ValidateAndSanitizeConfiguration(configuration, blob);
+            if (!ModelState.IsValid)
+                return this.CreateValidationError(ModelState);
+
+            PopulateBlob(configuration, blob);
+
+            storeData.SetStoreBlob(blob);
+
+            await _storeRepository.UpdateStore(storeData);
+
+
+            return GetStoreRateConfiguration();
+        }
+
+        [HttpPost("preview")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings, AuthenticationSchemes = AuthenticationSchemes.Greenfield)]
+        public async Task<IActionResult> PreviewUpdateStoreRateConfiguration(
+            StoreRateConfiguration configuration, [FromQuery] string[] currencyPair)
+        {
+            var data = HttpContext.GetStoreData();
+            var blob = data.GetStoreBlob();
+            var parsedCurrencyPairs = new HashSet<CurrencyPair>();
+
+
+            foreach (var pair in currencyPair ?? Array.Empty<string>())
+            {
+                if (!CurrencyPair.TryParse(pair, out var currencyPairParsed))
+                {
+                    ModelState.AddModelError(nameof(currencyPair),
+                        $"Invalid currency pair '{pair}' (it should be formatted like BTC_USD,BTC_CAD)");
+                    break;
+                }
+
+                parsedCurrencyPairs.Add(currencyPairParsed);
+            }
+            ValidateAndSanitizeConfiguration(configuration, blob);
+            if (!ModelState.IsValid)
+                return this.CreateValidationError(ModelState);
+            PopulateBlob(configuration, blob);
+
+            var rules = blob.GetRateRules(_btcPayNetworkProvider);
+
+
+            var rateTasks = _rateProviderFactory.FetchRates(parsedCurrencyPairs, rules, CancellationToken.None);
+            await Task.WhenAll(rateTasks.Values);
+            var result = new List<StoreRatePreviewResult>();
+            foreach (var rateTask in rateTasks)
+            {
+                var rateTaskResult = rateTask.Value.Result;
+
+                result.Add(new StoreRatePreviewResult()
+                {
+                    CurrencyPair = rateTask.Key.ToString(),
+                    Errors = rateTaskResult.Errors.Select(errors => errors.ToString()).ToList(),
+                    Rate = rateTaskResult.Errors.Any() ? (decimal?)null : rateTaskResult.BidAsk.Bid
+                });
+            }
+
+            return Ok(result);
+        }
+
+        private void ValidateAndSanitizeConfiguration(StoreRateConfiguration? configuration, StoreBlob storeBlob)
+        {
+            if (configuration is null)
+            {
+                ModelState.AddModelError("", "Body required");
+                return;
+            }
+            if (configuration.Spread < 0 || configuration.Spread > 100)
+            {
+                ModelState.AddModelError(nameof(configuration.Spread),
+                    $"Spread value must be in %, between 0 and 100");
+            }
+
+            if (configuration.IsCustomScript)
+            {
+                if (string.IsNullOrEmpty(configuration.EffectiveScript))
+                {
+                    configuration.EffectiveScript = storeBlob.GetDefaultRateRules(_btcPayNetworkProvider).ToString();
+                }
+
+                if (!RateRules.TryParse(configuration.EffectiveScript, out var r))
+                {
+                    ModelState.AddModelError(nameof(configuration.EffectiveScript),
+                   $"Script syntax is invalid");
+                }
+                else
+                {
+                    configuration.EffectiveScript = r.ToString();
+                }
+
+                if (!string.IsNullOrEmpty(configuration.PreferredSource))
+                {
+                    ModelState.AddModelError(nameof(configuration.PreferredSource),
+$"You can't set the preferredSource if you are using custom scripts");
+                }
+            }
+            else
+            {
+                if (!string.IsNullOrEmpty(configuration.EffectiveScript))
+                {
+                    ModelState.AddModelError(nameof(configuration.EffectiveScript),
+                    $"You can't set the effectiveScript if you aren't using custom scripts");
+                }
+                if (string.IsNullOrEmpty(configuration.PreferredSource))
+                {
+                    ModelState.AddModelError(nameof(configuration.PreferredSource),
+$"The preferredSource is required if you aren't using custom scripts");
+                }
+
+                configuration.PreferredSource = _rateProviderFactory
+                    .RateProviderFactory
+                    .GetSupportedExchanges()
+                    .FirstOrDefault(s =>
+                        s.Id.Equals(configuration.PreferredSource,
+                            StringComparison.InvariantCultureIgnoreCase))?.Id;
+
+                if (string.IsNullOrEmpty(configuration.PreferredSource))
+                {
+                    ModelState.AddModelError(nameof(configuration.PreferredSource),
+                    $"Unsupported source, please check /misc/rate-sources to see valid values ({configuration.PreferredSource})");
+                }
+            }
+        }
+
+        private static void PopulateBlob(StoreRateConfiguration configuration, StoreBlob storeBlob)
+        {
+            storeBlob.PreferredExchange = configuration.PreferredSource;
+            storeBlob.Spread = configuration.Spread / 100.0m;
+            storeBlob.RateScripting = configuration.IsCustomScript;
+            storeBlob.RateScript = configuration.EffectiveScript;
+        }
+    }
+}

BTCPayServer/Controllers/GreenField/GreenfieldStoresController.cs

@@ -127,6 +127,7 @@ namespace BTCPayServer.Controllers.Greenfield
                 //we do not include PaymentMethodCriteria because moving the CurrencyValueJsonConverter to the Client csproj is hard and requires a refactor (#1571 & #1572)
                 NetworkFeeMode = storeBlob.NetworkFeeMode,
                 RequiresRefundEmail = storeBlob.RequiresRefundEmail,
+                CheckoutType = storeBlob.CheckoutType,
                 Receipt = InvoiceDataBase.ReceiptOptions.Merge(storeBlob.ReceiptOptions, null),
                 LightningAmountInSatoshi = storeBlob.LightningAmountInSatoshi,
                 LightningPrivateRouteHints = storeBlob.LightningPrivateRouteHints,
@@ -165,6 +166,7 @@ namespace BTCPayServer.Controllers.Greenfield
             blob.NetworkFeeMode = restModel.NetworkFeeMode;
             blob.DefaultCurrency = restModel.DefaultCurrency;
             blob.RequiresRefundEmail = restModel.RequiresRefundEmail;
+            blob.CheckoutType = restModel.CheckoutType;
             blob.ReceiptOptions = InvoiceDataBase.ReceiptOptions.Merge(restModel.Receipt, null);
             blob.LightningAmountInSatoshi = restModel.LightningAmountInSatoshi;
             blob.LightningPrivateRouteHints = restModel.LightningPrivateRouteHints;

BTCPayServer/Controllers/GreenField/LocalBTCPayServerClient.cs

@@ -215,7 +215,6 @@ namespace BTCPayServer.Controllers.Greenfield
             throw new NotSupportedException("This method is not supported by the LocalBTCPayServerClient.");
         }
 
-
         public override async Task<MarketTradeResponseData> MarketTradeCustodianAccountAsset(string storeId, string accountId,
             TradeRequestData request, CancellationToken cancellationToken = default)
         {
@@ -223,6 +222,40 @@ namespace BTCPayServer.Controllers.Greenfield
                 await GetController<GreenfieldCustodianAccountController>().MarketTradeCustodianAccountAsset(storeId, accountId, request, cancellationToken));
         }
 
+        public override async Task<OnChainWalletObjectData[]> GetOnChainWalletObjects(string storeId, string cryptoCode,
+            GetWalletObjectsRequest query = null,
+            CancellationToken token = default)
+        {
+            return GetFromActionResult<OnChainWalletObjectData[]>(
+                await GetController<GreenfieldStoreOnChainWalletsController>().GetOnChainWalletObjects(storeId, cryptoCode, query?.Type, query?.Ids, query?.IncludeNeighbourData));
+        }
+
+        public override async Task<OnChainWalletObjectData> GetOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId, bool? includeNeighbourData = null, CancellationToken token = default)
+        {
+            return GetFromActionResult<OnChainWalletObjectData>(
+                await GetController<GreenfieldStoreOnChainWalletsController>().GetOnChainWalletObject(storeId, cryptoCode, objectId.Type, objectId.Id, includeNeighbourData));
+        }
+        public override async Task<OnChainWalletObjectData> AddOrUpdateOnChainWalletObject(string storeId, string cryptoCode, AddOnChainWalletObjectRequest request, CancellationToken token = default)
+        {
+            return GetFromActionResult<OnChainWalletObjectData>(
+                await GetController<GreenfieldStoreOnChainWalletsController>().AddOrUpdateOnChainWalletObject(storeId, cryptoCode, request));
+        }
+
+        public override async Task RemoveOnChainWalletLinks(string storeId, string cryptoCode, OnChainWalletObjectId objectId, OnChainWalletObjectId link, CancellationToken token = default)
+        {
+            HandleActionResult(await GetController<GreenfieldStoreOnChainWalletsController>().RemoveOnChainWalletLink(storeId, cryptoCode, objectId.Type, objectId.Id, link.Type, link.Id));
+        }
+
+        public override async Task RemoveOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId, CancellationToken token = default)
+        {
+            HandleActionResult(await GetController<GreenfieldStoreOnChainWalletsController>().RemoveOnChainWalletObject(storeId, cryptoCode, objectId.Type, objectId.Id));
+        }
+
+        public override async Task AddOrUpdateOnChainWalletLink(string storeId, string cryptoCode, OnChainWalletObjectId objectId, AddOnChainWalletObjectLinkRequest request = null, CancellationToken token = default)
+        {
+            HandleActionResult(await GetController<GreenfieldStoreOnChainWalletsController>().AddOrUpdateOnChainWalletLinks(storeId, cryptoCode, objectId.Type, objectId.Id, request));
+        }
+
         public override async Task<StoreWebhookData> CreateWebhook(string storeId, CreateStoreWebhookRequest create,
             CancellationToken token = default)
         {
@@ -324,7 +357,7 @@ namespace BTCPayServer.Controllers.Greenfield
             CancellationToken cancellationToken = default)
         {
             return GetFromActionResult<PayoutData>(
-                await GetController<GreenfieldPullPaymentController>().CreatePayout(pullPaymentId, payoutRequest));
+                await GetController<GreenfieldPullPaymentController>().CreatePayout(pullPaymentId, payoutRequest, cancellationToken));
         }
 
         public override async Task CancelPayout(string storeId, string payoutId,
@@ -351,7 +384,7 @@ namespace BTCPayServer.Controllers.Greenfield
             CancellationToken token = default)
         {
             return GetFromActionResult<LightningNodeBalanceData>(
-                await GetController<GreenfieldStoreLightningNodeApiController>().GetBalance(cryptoCode));
+                await GetController<GreenfieldStoreLightningNodeApiController>().GetBalance(cryptoCode, token));
         }
 
         public override async Task ConnectToLightningNode(string storeId, string cryptoCode,
@@ -381,10 +414,11 @@ namespace BTCPayServer.Controllers.Greenfield
                 await GetController<GreenfieldStoreLightningNodeApiController>().GetDepositAddress(cryptoCode, token));
         }
 
-        public override async Task PayLightningInvoice(string storeId, string cryptoCode,
+        public override async Task<LightningPaymentData> PayLightningInvoice(string storeId, string cryptoCode,
             PayLightningInvoiceRequest request, CancellationToken token = default)
         {
-            HandleActionResult(await GetController<GreenfieldStoreLightningNodeApiController>().PayInvoice(cryptoCode, request, token));
+            return GetFromActionResult<LightningPaymentData>(
+                await GetController<GreenfieldStoreLightningNodeApiController>().PayInvoice(cryptoCode, request, token));
         }
 
         public override async Task<LightningInvoiceData> GetLightningInvoice(string storeId, string cryptoCode,
@@ -394,6 +428,13 @@ namespace BTCPayServer.Controllers.Greenfield
                 await GetController<GreenfieldStoreLightningNodeApiController>().GetInvoice(cryptoCode, invoiceId, token));
         }
 
+        public override async Task<LightningInvoiceData[]> GetLightningInvoices(string storeId, string cryptoCode,
+            bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+        {
+            return GetFromActionResult<LightningInvoiceData[]>(
+                await GetController<GreenfieldStoreLightningNodeApiController>().GetInvoices(cryptoCode, pendingOnly, offsetIndex, token));
+        }
+
         public override async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
             CreateLightningInvoiceRequest request, CancellationToken token = default)
         {
@@ -455,6 +496,13 @@ namespace BTCPayServer.Controllers.Greenfield
                 await GetController<GreenfieldInternalLightningNodeApiController>().GetInvoice(cryptoCode, invoiceId, token));
         }
 
+        public override async Task<LightningInvoiceData[]> GetLightningInvoices(string cryptoCode,
+            bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+        {
+            return GetFromActionResult<LightningInvoiceData[]>(
+                await GetController<GreenfieldInternalLightningNodeApiController>().GetInvoices(cryptoCode, pendingOnly, offsetIndex, token));
+        }
+
         public override async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode,
             CreateLightningInvoiceRequest request,
             CancellationToken token = default)
@@ -577,6 +625,12 @@ namespace BTCPayServer.Controllers.Greenfield
             HandleActionResult(await GetController<GreenfieldPaymentRequestsController>().ArchivePaymentRequest(storeId, paymentRequestId));
         }
 
+        public override async Task<InvoiceData> PayPaymentRequest(string storeId, string paymentRequestId, PayPaymentRequestRequest request, CancellationToken token = default)
+        {
+            return GetFromActionResult<InvoiceData>(
+                await GetController<GreenfieldPaymentRequestsController>().PayPaymentRequest(storeId, paymentRequestId, request, token));
+        }
+
         public override async Task<PaymentRequestData> CreatePaymentRequest(string storeId,
             CreatePaymentRequestRequest request, CancellationToken token = default)
         {
@@ -1111,6 +1165,14 @@ namespace BTCPayServer.Controllers.Greenfield
                await GetController<GreenfieldAppsController>().UpdatePointOfSaleApp(appId, request));
         }
 
+        public override async Task<CrowdfundAppData> CreateCrowdfundApp(
+            string storeId,
+            CreateCrowdfundAppRequest request, CancellationToken token = default)
+        {
+            return GetFromActionResult<CrowdfundAppData>(
+                await GetController<GreenfieldAppsController>().CreateCrowdfundApp(storeId, request));
+        }
+
         public override async Task<AppDataBase> GetApp(string appId, CancellationToken token = default)
         {
             return GetFromActionResult<AppDataBase>(
@@ -1121,5 +1183,52 @@ namespace BTCPayServer.Controllers.Greenfield
         {
             HandleActionResult(await GetController<GreenfieldAppsController>().DeleteApp(appId));
         }
+
+        public override Task<List<RateSource>> GetRateSources(CancellationToken token = default)
+        {
+            return Task.FromResult(GetFromActionResult(GetController<GreenfieldStoreRateConfigurationController>().GetRateSources()));
+        }
+
+        public override Task<StoreRateConfiguration> GetStoreRateConfiguration(string storeId, CancellationToken token = default)
+        {
+            return Task.FromResult(GetFromActionResult<StoreRateConfiguration>(GetController<GreenfieldStoreRateConfigurationController>().GetStoreRateConfiguration()));
+        }
+
+        public override async Task<List<StoreRatePreviewResult>> PreviewUpdateStoreRateConfiguration(string storeId,
+            StoreRateConfiguration request,
+            string[] currencyPair,
+            CancellationToken token = default)
+        {
+            return GetFromActionResult<List<StoreRatePreviewResult>>(
+                await GetController<GreenfieldStoreRateConfigurationController>().PreviewUpdateStoreRateConfiguration(request,
+                    currencyPair));
+        }
+
+        public override async Task<StoreRateConfiguration> UpdateStoreRateConfiguration(string storeId, StoreRateConfiguration request, CancellationToken token = default)
+        {
+            return GetFromActionResult<StoreRateConfiguration>(await GetController<GreenfieldStoreRateConfigurationController>().UpdateStoreRateConfiguration(request));
+        }
+
+        public override async Task MarkPayoutPaid(string storeId, string payoutId, CancellationToken cancellationToken = default)
+        {
+            HandleActionResult(await GetController<GreenfieldPullPaymentController>().MarkPayoutPaid(storeId, payoutId, cancellationToken));
+        }
+
+        public override async Task MarkPayout(string storeId, string payoutId, MarkPayoutRequest request,
+            CancellationToken cancellationToken = default)
+        {
+            HandleActionResult(await GetController<GreenfieldPullPaymentController>().MarkPayout(storeId, payoutId, request));
+        }
+
+        public override async Task<PayoutData> GetPullPaymentPayout(string pullPaymentId, string payoutId, CancellationToken cancellationToken = default)
+        {
+            return GetFromActionResult<PayoutData>(await GetController<GreenfieldPullPaymentController>().GetPayout(pullPaymentId, payoutId));
+        }
+
+        public override async Task<PayoutData> GetStorePayout(string storeId, string payoutId,
+            CancellationToken cancellationToken = default)
+        {
+            return GetFromActionResult<PayoutData>(await GetController<GreenfieldPullPaymentController>().GetStorePayout(storeId, payoutId));
+        }
     }
 }

BTCPayServer/Controllers/UIAccountController.cs

@@ -227,7 +227,7 @@ namespace BTCPayServer.Controllers
 
         private async Task<LoginWithFido2ViewModel> BuildFido2ViewModel(bool rememberMe, ApplicationUser user)
         {
-            if (_btcPayServerEnvironment.IsSecure)
+            if (_btcPayServerEnvironment.IsSecure(HttpContext))
             {
                 var r = await _fido2Service.RequestLogin(user.Id);
                 if (r is null)
@@ -247,7 +247,7 @@ namespace BTCPayServer.Controllers
 
         private async Task<LoginWithLNURLAuthViewModel> BuildLNURLAuthViewModel(bool rememberMe, ApplicationUser user)
         {
-            if (_btcPayServerEnvironment.IsSecure)
+            if (_btcPayServerEnvironment.IsSecure(HttpContext))
             {
                 var r = await _lnurlAuthService.RequestLogin(user.Id);
                 if (r is null)
@@ -777,7 +777,7 @@ namespace BTCPayServer.Controllers
 
         private bool CanLoginOrRegister()
         {
-            return _btcPayServerEnvironment.IsDeveloping || _btcPayServerEnvironment.IsSecure;
+            return _btcPayServerEnvironment.IsDeveloping || _btcPayServerEnvironment.IsSecure(HttpContext);
         }
 
         private void SetInsecureFlags()

BTCPayServer/Controllers/UIInvoiceController.Testing.cs

@@ -1,8 +1,10 @@
 using System;
+using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
 using BTCPayServer.Filters;
+using BTCPayServer.Lightning;
 using BTCPayServer.Payments;
 using BTCPayServer.Services;
 using Microsoft.AspNetCore.Mvc;
@@ -16,6 +18,7 @@ namespace BTCPayServer.Controllers
         {
             public Decimal Amount { get; set; }
             public string CryptoCode { get; set; } = "BTC";
+            public string PaymentMethodId { get; set; } = "BTC";
         }
 
         public class MineBlocksRequest
@@ -24,36 +27,71 @@ namespace BTCPayServer.Controllers
             public string CryptoCode { get; set; } = "BTC";
         }
 
-        [HttpPost]
-        [Route("i/{invoiceId}/test-payment")]
+        [HttpPost("i/{invoiceId}/test-payment")]
         [CheatModeRoute]
         public async Task<IActionResult> TestPayment(string invoiceId, FakePaymentRequest request, [FromServices] Cheater cheater)
         {
             var invoice = await _InvoiceRepository.GetInvoice(invoiceId);
             var store = await _StoreRepository.FindStore(invoice.StoreId);
-
-            // TODO support altcoins, not just bitcoin
-            var network = _NetworkProvider.GetNetwork<BTCPayNetwork>(request.CryptoCode);
-            var paymentMethodId = new [] {store.GetDefaultPaymentId()}.Concat(store.GetEnabledPaymentIds(_NetworkProvider))
-                .FirstOrDefault(p => p!= null && p.CryptoCode == request.CryptoCode && p.PaymentType == PaymentTypes.BTCLike);
-            var bitcoinAddressString = invoice.GetPaymentMethod(paymentMethodId).GetPaymentMethodDetails().GetPaymentDestination();
-            var bitcoinAddressObj = BitcoinAddress.Create(bitcoinAddressString, network.NBitcoinNetwork);
-            var BtcAmount = request.Amount;
-
+            var isSats = request.CryptoCode.ToUpper(CultureInfo.InvariantCulture) == "SATS";
+            var cryptoCode = isSats ? "BTC" : request.CryptoCode;
+            var amount = new Money(request.Amount, isSats ? MoneyUnit.Satoshi : MoneyUnit.BTC);
+            var network = _NetworkProvider.GetNetwork<BTCPayNetwork>(cryptoCode).NBitcoinNetwork;
+            var paymentMethodId = new [] {store.GetDefaultPaymentId()}
+                .Concat(store.GetEnabledPaymentIds(_NetworkProvider))
+                .FirstOrDefault(p => p?.ToString() == request.PaymentMethodId);
+            
             try
             {
                 var paymentMethod = invoice.GetPaymentMethod(paymentMethodId);
-                var rate = paymentMethod.Rate;
-                var txid = cheater.CashCow.SendToAddress(bitcoinAddressObj, new Money(BtcAmount, MoneyUnit.BTC)).ToString();
-
-                // TODO The value of totalDue is wrong. How can we get the real total due? invoice.Price is only correct if this is the 2nd payment, not for a 3rd or 4th payment. 
-                var totalDue = invoice.Price;
-                return Ok(new
+                var destination = paymentMethod?.GetPaymentMethodDetails().GetPaymentDestination();
+                
+                switch (paymentMethod?.GetId().PaymentType)
                 {
-                    Txid = txid,
-                    AmountRemaining = (totalDue - (BtcAmount * rate)) / rate,
-                    SuccessMessage = "Created transaction " + txid
-                });
+                    case BitcoinPaymentType:
+                        var address = BitcoinAddress.Create(destination, network);
+                        var txid = (await cheater.CashCow.SendToAddressAsync(address, amount)).ToString();
+                        
+                        return Ok(new
+                        {
+                            Txid = txid,
+                            AmountRemaining = (paymentMethod.Calculate().Due - amount).ToUnit(MoneyUnit.BTC),
+                            SuccessMessage = $"Created transaction {txid}" 
+                        });
+
+                    case LightningPaymentType:
+                        // requires the channels to be set up using the BTCPayServer.Tests/docker-lightning-channel-setup.sh script
+                        LightningConnectionString.TryParse(Environment.GetEnvironmentVariable("BTCPAY_BTCEXTERNALLNDREST"), false, out var lnConnection);
+                        var lnClient = LightningClientFactory.CreateClient(lnConnection, network);
+                        var lnAmount = new LightMoney(amount.Satoshi, LightMoneyUnit.Satoshi);
+                        var response = await lnClient.Pay(destination, new PayInvoiceParams { Amount = lnAmount });
+
+                        if (response.Result == PayResult.Ok)
+                        {
+                            var bolt11 = BOLT11PaymentRequest.Parse(destination, network);
+                            var paymentHash = bolt11.PaymentHash?.ToString();
+                            var paid = new Money(response.Details.TotalAmount.ToUnit(LightMoneyUnit.Satoshi), MoneyUnit.Satoshi);
+                            return Ok(new
+                            {
+                                Txid = paymentHash,
+                                AmountRemaining = (paymentMethod.Calculate().TotalDue - paid).ToUnit(MoneyUnit.BTC),
+                                SuccessMessage = $"Sent payment {paymentHash}" 
+                            });
+                        }
+                        return UnprocessableEntity(new
+                        {
+                            ErrorMessage = response.ErrorDetail,
+                            AmountRemaining = invoice.Price
+                        });
+
+                    default:
+                        return UnprocessableEntity(new
+                        {
+                            ErrorMessage = $"Payment method {paymentMethodId} is not supported",
+                            AmountRemaining = invoice.Price
+                        });
+                }
+                
             }
             catch (Exception e)
             {
@@ -65,46 +103,34 @@ namespace BTCPayServer.Controllers
             }
         }
 
-        [HttpPost]
-        [Route("i/{invoiceId}/mine-blocks")]
+        [HttpPost("i/{invoiceId}/mine-blocks")]
         [CheatModeRoute]
         public IActionResult MineBlock(string invoiceId, MineBlocksRequest request, [FromServices] Cheater cheater)
         {
-            // TODO support altcoins, not just bitcoin
             var blockRewardBitcoinAddress = cheater.CashCow.GetNewAddress();
             try
             {
                 if (request.BlockCount > 0)
                 {
                     cheater.CashCow.GenerateToAddress(request.BlockCount, blockRewardBitcoinAddress);
-                    return Ok(new
-                    {
-                        SuccessMessage = "Mined " + request.BlockCount + " blocks"
-                    });
+                    return Ok(new { SuccessMessage = $"Mined {request.BlockCount} block{(request.BlockCount == 1 ? "" : "s")} " });
                 }
-                return BadRequest(new
-                {
-                    ErrorMessage = "Number of blocks should be > 0"
-                });
+                return BadRequest(new { ErrorMessage = "Number of blocks should be at least 1" });
             }
             catch (Exception e)
             {
-                return BadRequest(new
-                {
-                    ErrorMessage = e.Message
-                });
+                return BadRequest(new { ErrorMessage = e.Message });
             }
         }
 
-        [HttpPost]
-        [Route("i/{invoiceId}/expire")]
+        [HttpPost("i/{invoiceId}/expire")]
         [CheatModeRoute]
-        public async Task<IActionResult> TestExpireNow(string invoiceId, [FromServices] Cheater cheater)
+        public async Task<IActionResult> Expire(string invoiceId, int seconds, [FromServices] Cheater cheater)
         {
             try
             {
-                await cheater.UpdateInvoiceExpiry(invoiceId, DateTimeOffset.Now);
-                return Ok(new { SuccessMessage = "Invoice is now expired." });
+                await cheater.UpdateInvoiceExpiry(invoiceId, TimeSpan.FromSeconds(seconds));
+                return Ok(new { SuccessMessage = $"Invoice set to expire in {seconds} seconds." });
             }
             catch (Exception e)
             {