make port binding respect defaults to avoid any behavior change from older versions

closes #4038

.circleci/config.yml

@@ -2,15 +2,15 @@ version: 2
 jobs:
   fast_tests:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
       - checkout
       - run:
           command: |
-            cd .circleci && ./run-tests.sh "Fast=Fast" && ./can-build.sh
+            cd .circleci && ./run-tests.sh "Fast=Fast|ThirdParty=ThirdParty" && ./can-build.sh
   selenium_tests:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
       - checkout
       - run:
@@ -18,32 +18,26 @@ jobs:
             cd .circleci && ./run-tests.sh "Selenium=Selenium"
   integration_tests:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
       - checkout
       - run:
           command: |
             cd .circleci && ./run-tests.sh "Integration=Integration"
-  external_tests:
+  trigger_docs_build:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
-      - checkout
       - run:
           command: |
-            if [ "$CIRCLE_PROJECT_USERNAME" == "btcpayserver" ] && [ "$CIRCLE_PROJECT_REPONAME" == "btcpayserver" ]; then
-                cd .circleci && ./run-tests.sh "ExternalIntegration=ExternalIntegration"
-            else
-              echo "Skipping running ExternalIntegration tests outside of context of main user and repository that have access to secrets"
-            fi
-
+            curl -X POST -H "Authorization: token $GH_PAT" -H "Accept: application/vnd.github.everest-preview+json" -H "Content-Type: application/json" https://api.github.com/repos/btcpayserver/btcpayserver-doc/dispatches --data '{"event_type": "build_docs"}'
 
   # publish jobs require $DOCKERHUB_REPO, $DOCKERHUB_USER, $DOCKERHUB_PASS defined
   amd64:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
-      - checkout  
+      - checkout
       - run:
           command: |
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
@@ -56,9 +50,9 @@ jobs:
 
   arm32v7:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
-      - checkout  
+      - checkout
       - run:
           command: |
             sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
@@ -72,9 +66,9 @@ jobs:
 
   arm64v8:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
-      - checkout  
+      - checkout
       - run:
           command: |
             sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
@@ -88,15 +82,10 @@ jobs:
 
   multiarch:
     machine:
-      enabled: true
-      image: circleci/classic:201808-01
+      image: ubuntu-2004:202201-02
     steps:
       - run:
           command: |
-            # Turn on Experimental features
-            sudo mkdir $HOME/.docker
-            sudo sh -c 'echo "{ \"experimental\": \"enabled\" }" >> $HOME/.docker/config.json'
-            #
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             #
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
@@ -105,8 +94,7 @@ jobs:
             sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 --os linux --arch arm --variant v7
             sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 --os linux --arch arm64 --variant v8
             sudo docker manifest push $DOCKERHUB_REPO:$LATEST_TAG -p
-            
-            
+
             sudo docker manifest create --amend $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8
             sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 --os linux --arch amd64
             sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 --os linux --arch arm --variant v7
@@ -120,12 +108,15 @@ workflows:
       - fast_tests
       - selenium_tests
       - integration_tests
-      - external_tests:
-          filters:
-            branches:
-                only: master
   publish:
     jobs:
+      - trigger_docs_build:
+          filters:
+            branches:
+              ignore: /.*/
+            # only act on version tags
+            tags:
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
       - amd64:
           filters:
             # ignore any commit on any branch by default
@@ -135,7 +126,6 @@ workflows:
             # OR feature tags like vlndseedbackup
             # OR features on specific versions like v1.0.0.88-lndseedbackup-1
             tags:
-
               only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
       - arm32v7:
           filters:

.circleci/run-tests.sh

@@ -4,6 +4,15 @@ set -e
 cd ../BTCPayServer.Tests
 docker-compose -v
 docker-compose -f "docker-compose.altcoins.yml" down --v
-docker-compose -f "docker-compose.altcoins.yml" pull
+
+# For some reason, docker-compose pull fails time to time, so we try several times
+n=0
+until [ "$n" -ge 10 ]
+do
+   docker-compose -f "docker-compose.altcoins.yml" pull && break
+   n=$((n+1)) 
+   sleep 5
+done
+
 docker-compose -f "docker-compose.altcoins.yml" build
 docker-compose -f "docker-compose.altcoins.yml" run -e "TEST_FILTERS=$1" tests

.editorconfig

@@ -121,8 +121,11 @@ csharp_space_between_method_declaration_name_and_open_parenthesis = false
 csharp_space_between_method_declaration_parameter_list_parentheses = false
 csharp_space_between_parentheses = false
 csharp_space_between_square_brackets = false
+csharp_style_prefer_null_check_over_type_check = true:warning
+csharp_prefer_simple_using_statement = true:warning
 
 # C++ Files
+
 [*.{cpp,h,in}]
 curly_bracket_next_line = true
 indent_brace_style = Allman

.github/ISSUE_TEMPLATE/bug-report.md

@@ -1,38 +0,0 @@
----
-name: Bug report
-about: File a bug report
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Your BTCPay Environment (please complete the following information):**
-- BTCPay Server Version: [available in the right bottom corner of footer] 
-- Deployment Method: [e.g. Docker, Manual, Third-Party-host]
-- Browser: [e.g. Chrome, Safari]
-
-**Logs (if applicable)**
-Basic logs can be found in Server Settings > Logs. More logs https://docs.btcpayserver.org/Troubleshooting/#2-looking-through-the-logs
-
-**Setup Parameters**
-If you're reporting a deployment issue run `. btcpay-setup.sh -i` and paste the setup parameters here with your private information removed or obscured.
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,68 @@
+name: 🐛 Bug Report
+description: File a bug report
+title: "[Bug]: "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! Please provide as much information as you can. It helps us better understand the problem and fix it faster.
+  - type: textarea
+    id: version
+    attributes:
+      label: What is your BTCPay version?
+      description: You can see the version in the footer's bottom right corner
+      placeholder: I'm running BTCPay v1.X.X.X
+    validations:
+      required: true
+  - type: textarea
+    id: deployment
+    attributes:
+      label: How did you deploy BTCPay Server?
+      description: Docker, manual, third-party host? Read more on deployment methods [here](https://docs.btcpayserver.org/Deployment/)
+      placeholder: I'm running BTCPay Server on a...
+    validations:
+      required: true
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: A clear and concise description of what the bug is.
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: How did you encounter this bug?
+      description: Step by step describe how did you encounter the bug?
+      placeholder: 1. I clicked X 2. Then I clicked Y 3. See error
+    validations:
+      required: true
+  - type: textarea
+    id: logoutput
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks. Logs can be found in Server Settings > Logs. Here's how you can [troubleshoot an issue](https://docs.btcpayserver.org/Troubleshooting/)
+      render: shell
+  - type: textarea
+    id: browser
+    attributes:
+      label: What browser do you use?
+      description: Provide your browser and it's version. If you replicated issues on multiple browsers, let us know which ones.
+      placeholder: For example Safari 15.00, Chrome 10.0, Tor, Edge, etc
+    validations:
+      required: false
+  - type: textarea
+    id: additonal
+    attributes:
+      label: Additional information
+      description: Feel free to provide additional information. Screenshots are always helpful.
+  - type: checkboxes
+    id: terms
+    attributes:
+      label: Are you sure this is a bug report?
+      description: By submitting this report, you agree that this is not a support or a feature request. For general questions please read our [documentation](https://docs.btcpayserver.org). You can ask questions in [discussions](https://github.com/btcpayserver/btcpayserver/discussions) and [on our community chat](https://chat.btcpayserver.org)
+      options:
+        - label: I confirm this is a bug report
+          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,11 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
-  - name: Community Support Chat 
+  - name: 🚀 Discussions
+    url: https://github.com/btcpayserver/btcpayserver/discussions
+    about: Technical discussions, questions and feature requests
+  - name: 📝 Official Documentation
+    url: https://docs.btcpayserver.org
+    about: Check our documentation for answers to common questions
+  - name: 💬 Community Support Chat
     url: https://chat.btcpayserver.org/
-    about: Ask general questions and get community support in real-time.
+    about: Ask general questions and get community support in real-time

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,23 +0,0 @@
----
-name: Feature request
-about: Suggest a new feature or enhancement
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Sketch/Image/Wireframe/Mockup**
- If applicable provide examples, wireframes, sketches or images to better explain your idea.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.gitignore

@@ -299,3 +299,6 @@ BTCPayServer/wwwroot/bundles/*
 BTCPayServer/testpwd
 .DS_Store
 Packed Plugins
+Plugins/packed
+
+BTCPayServer/wwwroot/swagger/v1/openapi.json

.run/Build and pack extensions.run.xml

@@ -1,6 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Build and pack plugins" type="CompoundRunConfigurationType">
-    <toRun name="Pack Test Plugin" type="DotNetProject" />
-    <method v="2" />
-  </configuration>
-</component>

.vscode/launch.json

@@ -10,14 +10,14 @@
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/BTCPayServer/bin/Debug/netcoreapp3.1/BTCPayServer.dll",
+            "program": "${workspaceFolder}/BTCPayServer/bin/Debug/net6.0/BTCPayServer.dll",
             "args": [],
             "cwd": "${workspaceFolder}/BTCPayServer",
             "stopAtEntry": false,
             // Enable launching a web browser when ASP.NET Core starts. For more information: https://aka.ms/VSCode-CS-LaunchJson-WebBrowser
             "serverReadyAction": {
                 "action": "openExternally",
-                "pattern": "\\bListening on\\s+(https?://\\S+)"
+                "pattern": "\\bNow listening on:\\s+(https?://\\S+)"
             },
             "env": {
                 "ASPNETCORE_ENVIRONMENT": "Development"

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -31,9 +31,13 @@
     <None Include="icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.4" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.1.4" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.1.4" />
-    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="3.1.1" />
+    <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="Pomelo.EntityFrameworkCore.MySql" Version="6.0.1" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\BTCPayServer.Client\BTCPayServer.Client.csproj" />
   </ItemGroup>
 </Project>

BTCPayServer.Abstractions/Configuration/DataDirectories.cs

@@ -0,0 +1,11 @@
+namespace BTCPayServer.Configuration
+{
+    public class DataDirectories
+    {
+        public string DataDir { get; set; }
+        public string PluginDir { get; set; }
+        public string TempStorageDir { get; set; }
+        public string StorageDir { get; set; }
+        public string TempDir { get; set; }
+    }
+}

BTCPayServer.Abstractions/Constants/WellKnownTempData.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Abstractions.Constants;
+
+public class WellKnownTempData
+{
+    public const string SuccessMessage = nameof(SuccessMessage);
+    public const string ErrorMessage = nameof(ErrorMessage);
+}

BTCPayServer.Abstractions/Contracts/BaseDbContextFactory.cs

@@ -3,17 +3,18 @@ using BTCPayServer.Abstractions.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.Extensions.Options;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations.Operations;
 
 namespace BTCPayServer.Abstractions.Contracts
 {
-    public abstract class BaseDbContextFactory<T> where T: DbContext
+    public abstract class BaseDbContextFactory<T> where T : DbContext
     {
-        private readonly DatabaseOptions _options;
+        private readonly IOptions<DatabaseOptions> _options;
         private readonly string _schemaPrefix;
 
-        public BaseDbContextFactory(DatabaseOptions options, string schemaPrefix)
+        public BaseDbContextFactory(IOptions<DatabaseOptions> options, string schemaPrefix)
         {
             _options = options;
             _schemaPrefix = schemaPrefix;
@@ -23,7 +24,9 @@ namespace BTCPayServer.Abstractions.Contracts
 
         class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
         {
-            public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies, IMigrationsAnnotationProvider annotations, Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal.INpgsqlOptions opts) : base(dependencies, annotations, opts)
+#pragma warning disable EF1001 // Internal EF Core API usage.
+            public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies, Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal.INpgsqlSingletonOptions opts) : base(dependencies, opts)
+#pragma warning restore EF1001 // Internal EF Core API usage.
             {
             }
 
@@ -65,10 +68,10 @@ namespace BTCPayServer.Abstractions.Contracts
 
         public void ConfigureBuilder(DbContextOptionsBuilder builder)
         {
-            switch (_options.DatabaseType)
+            switch (_options.Value.DatabaseType)
             {
                 case DatabaseType.Sqlite:
-                    builder.UseSqlite(_options.ConnectionString, o =>
+                    builder.UseSqlite(_options.Value.ConnectionString, o =>
                     {
                         if (!string.IsNullOrEmpty(_schemaPrefix))
                         {
@@ -78,7 +81,7 @@ namespace BTCPayServer.Abstractions.Contracts
                     break;
                 case DatabaseType.Postgres:
                     builder
-                        .UseNpgsql(_options.ConnectionString, o =>
+                        .UseNpgsql(_options.Value.ConnectionString, o =>
                         {
                             o.EnableRetryOnFailure(10);
                             if (!string.IsNullOrEmpty(_schemaPrefix))
@@ -89,10 +92,10 @@ namespace BTCPayServer.Abstractions.Contracts
                         .ReplaceService<IMigrationsSqlGenerator, CustomNpgsqlMigrationsSqlGenerator>();
                     break;
                 case DatabaseType.MySQL:
-                    builder.UseMySql(_options.ConnectionString, o =>
+                    builder.UseMySql(_options.Value.ConnectionString, ServerVersion.AutoDetect(_options.Value.ConnectionString), o =>
                     {
                         o.EnableRetryOnFailure(10);
-                            
+
                         if (!string.IsNullOrEmpty(_schemaPrefix))
                         {
                             o.MigrationsHistoryTable(_schemaPrefix);
@@ -103,6 +106,6 @@ namespace BTCPayServer.Abstractions.Contracts
                     throw new ArgumentOutOfRangeException();
             }
         }
-        
+
     }
 }

BTCPayServer.Abstractions/Contracts/IBTCPayServerClientFactory.cs

@@ -0,0 +1,12 @@
+using System.Threading.Tasks;
+using BTCPayServer.Client;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface IBTCPayServerClientFactory
+    {
+        Task<BTCPayServerClient> Create(string userId, params string[] storeIds);
+        Task<BTCPayServerClient> Create(string userId, string[] storeIds, HttpContext httpRequest);
+    }
+}

BTCPayServer.Abstractions/Contracts/IBTCPayServerPlugin.cs

@@ -28,5 +28,5 @@ namespace BTCPayServer.Abstractions.Contracts
             }
         }
     }
-    
+
 }

BTCPayServer.Abstractions/Contracts/IFileService.cs

@@ -0,0 +1,17 @@
+#nullable enable
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IFileService
+{
+    Task<bool> IsAvailable();
+    Task<IStoredFile> AddFile(IFormFile file, string userId);
+    Task<IStoredFile> AddFile(Uri file, string userId);
+    Task<string?> GetFileUrl(Uri baseUri, string fileId);
+    Task<string?> GetTemporaryFileUrl(Uri baseUri, string fileId, DateTimeOffset expiry,
+        bool isDownload);
+    Task RemoveFile(string fileId, string userId);
+}

BTCPayServer.Abstractions/Contracts/INotificationHandler.cs

@@ -7,7 +7,7 @@ namespace BTCPayServer.Abstractions.Contracts
         public abstract string Identifier { get; }
         public abstract string NotificationType { get; }
     }
-    
+
     public interface INotificationHandler
     {
         string NotificationType { get; }
@@ -15,7 +15,7 @@ namespace BTCPayServer.Abstractions.Contracts
         public (string identifier, string name)[] Meta { get; }
         void FillViewModel(object notification, NotificationViewModel vm);
     }
-    
+
     public class NotificationViewModel
     {
         public string Id { get; set; }

BTCPayServer.Abstractions/Contracts/IPluginHookFilter.cs

@@ -5,7 +5,7 @@ namespace BTCPayServer.Abstractions.Contracts
     public interface IPluginHookFilter
     {
         public string Hook { get; }
-        
+
         Task<object> Execute(object args);
     }
 }

BTCPayServer.Abstractions/Contracts/IScopeProvider.cs

@@ -0,0 +1,7 @@
+#nullable enable
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IScopeProvider
+{
+    string? GetCurrentStoreId();
+}

BTCPayServer.Abstractions/Contracts/ISettingsRepository.cs

@@ -1,3 +1,4 @@
+#nullable enable
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -5,8 +6,8 @@ namespace BTCPayServer.Abstractions.Contracts
 {
     public interface ISettingsRepository
     {
-        Task<T> GetSettingAsync<T>(string name = null);
-        Task UpdateSetting<T>(T obj, string name = null);
-        Task<T> WaitSettingsChanged<T>(CancellationToken cancellationToken = default);
+        Task<T?> GetSettingAsync<T>(string? name = null) where T : class;
+        Task UpdateSetting<T>(T obj, string? name = null) where T : class;
+        Task<T> WaitSettingsChanged<T>(CancellationToken cancellationToken = default) where T : class;
     }
 }

BTCPayServer.Abstractions/Contracts/IStoreRepository.cs

@@ -0,0 +1,12 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IStoreRepository
+{
+    Task<T?> GetSettingAsync<T>(string storeId, string name) where T : class;
+    Task<Dictionary<string, T?>> GetSettingsAsync<T>(string name) where T : class;
+    Task UpdateSetting<T>(string storeId, string name, T obj) where T : class;
+}

BTCPayServer.Abstractions/Contracts/IStoredFile.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IStoredFile
+{
+    string Id { get; set; }
+    string FileName { get; set; }
+    string StorageFileName { get; set; }
+    DateTime Timestamp { get; set; }
+    string ApplicationUserId { get; set; }
+}

BTCPayServer.Abstractions/Contracts/ISwaggerProvider.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface ISwaggerProvider
+{
+    Task<JObject> Fetch();
+}

BTCPayServer.Abstractions/Contracts/ISyncSummaryProvider.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 namespace BTCPayServer.Abstractions.Contracts
 {
     public interface ISyncSummaryProvider
@@ -5,5 +7,12 @@ namespace BTCPayServer.Abstractions.Contracts
         bool AllAvailable();
 
         string Partial { get; }
+        IEnumerable<ISyncStatus> GetStatuses();
+    }
+
+    public interface ISyncStatus
+    {
+        public string CryptoCode { get; set; }
+        public bool Available { get; }
     }
 }

BTCPayServer.Abstractions/Contracts/IUIExtension.cs

@@ -3,7 +3,7 @@ namespace BTCPayServer.Abstractions.Contracts
     public interface IUIExtension
     {
         string Partial { get; }
-        
+
         string Location { get; }
     }
 }

BTCPayServer.Abstractions/Contracts/IUTXOLocker.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using NBitcoin;
+
+namespace BTCPayServer.Payments.PayJoin;
+
+public interface IUTXOLocker
+{
+    Task<bool> TryLock(OutPoint outpoint);
+    Task<bool> TryUnlock(params OutPoint[] outPoints);
+    Task<bool> TryLockInputs(OutPoint[] outPoints);
+    Task<HashSet<OutPoint>> FindLocks(OutPoint[] outpoints);
+}

BTCPayServer.Abstractions/Custodians/Client/AssetQuoteResult.cs

@@ -0,0 +1,19 @@
+namespace BTCPayServer.Abstractions.Custodians.Client;
+
+public class AssetQuoteResult
+{
+    public string FromAsset { get; set; }
+    public string ToAsset { get; set; }
+    public decimal Bid { get; set; }
+    public decimal Ask { get; set; }
+
+    public AssetQuoteResult() { }
+
+    public AssetQuoteResult(string fromAsset, string toAsset,decimal bid, decimal ask)
+    {
+        FromAsset = fromAsset;
+        ToAsset = toAsset;
+        Bid = bid;
+        Ask = ask;
+    }
+}

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

@@ -0,0 +1,11 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class AssetBalancesUnavailableException : CustodianApiException
+{
+    
+    public AssetBalancesUnavailableException(System.Exception e) : base(500, "asset-balances-unavailable", $"Cannot fetch the asset balances: {e.Message}", e)
+    {
+    }
+
+    
+}

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

@@ -0,0 +1,13 @@
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class AssetQuoteUnavailableException : CustodianApiException
+{
+    public AssetPairData AssetPair { get; }
+
+    public AssetQuoteUnavailableException(AssetPairData assetPair) : base(400, "asset-price-unavailable", "Cannot find a quote for pair " + assetPair)
+    {
+        this.AssetPair = assetPair;
+    }
+}

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

@@ -0,0 +1,13 @@
+using System;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class BadConfigException : CustodianApiException
+{
+    public string[] BadConfigKeys { get; set; }
+
+    public BadConfigException(string[] badConfigKeys) : base(500, "bad-custodian-account-config", "Wrong config values: " + String.Join(", ", badConfigKeys))
+    {
+        this.BadConfigKeys = badConfigKeys;
+    }
+}

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

@@ -0,0 +1,13 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class CannotWithdrawException : CustodianApiException
+
+{
+    public CannotWithdrawException(ICustodian custodian, string paymentMethod, string message) : base(403, "cannot-withdraw", message)
+    {
+    }
+
+    public CannotWithdrawException(ICustodian custodian, string paymentMethod, string targetAddress, CustodianApiException originalException) : base(403, "cannot-withdraw", $"{custodian.Name} cannot withdraw {paymentMethod} to '{targetAddress}': {originalException.Message}")
+    {
+    }
+}

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

@@ -0,0 +1,16 @@
+using System;
+namespace BTCPayServer.Abstractions.Custodians;
+public class CustodianApiException: Exception {
+    public int HttpStatus { get; }
+    public string Code { get; }
+
+    public CustodianApiException(int httpStatus, string code, string message, System.Exception ex) : base(message, ex)
+    {
+        HttpStatus = httpStatus;
+        Code = code;
+    }
+    public CustodianApiException( int httpStatus, string code, string message) : this(httpStatus, code, message, null)
+    {
+    }
+}
+

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

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class CustodianFeatureNotImplementedException: CustodianApiException
+{
+    public CustodianFeatureNotImplementedException(string message) : base(400, "not-implemented", message)
+    {
+        
+    }
+}

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

@@ -0,0 +1,8 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class DepositsUnavailableException : CustodianApiException
+{
+    public DepositsUnavailableException(string message) : base(404, "deposits-unavailable", message)
+    {
+    }
+}

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

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class InsufficientFundsException : CustodianApiException
+{   
+    public InsufficientFundsException(string message) : base(400, "insufficient-funds", message)
+    {
+    }
+
+}

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

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class InvalidWithdrawalTargetException : CustodianApiException
+
+{
+    public InvalidWithdrawalTargetException(ICustodian custodian, string paymentMethod, string targetAddress, CustodianApiException originalException) : base(403, "invalid-withdrawal-target", $"{custodian.Name} cannot withdraw {paymentMethod} to '{targetAddress}': {originalException.Message}")
+    {
+    }
+}

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

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class PermissionDeniedCustodianApiException : CustodianApiException
+
+{
+    public PermissionDeniedCustodianApiException(ICustodian custodian) : base(403, "custodian-api-permission-denied", $"{custodian.Name}'s API reported that you don't have permission.")
+    {
+    }
+}

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

@@ -0,0 +1,11 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class TradeNotFoundException : CustodianApiException
+{
+    private string tradeId { get; }
+
+    public TradeNotFoundException(string tradeId) : base(404,"trade-not-found","Could not find trade ID " + tradeId)
+    {
+        this.tradeId = tradeId;
+    }
+}

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

@@ -0,0 +1,11 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class WithdrawalNotFoundException : CustodianApiException
+{
+    private string WithdrawalId { get; }
+
+    public WithdrawalNotFoundException(string withdrawalId) : base(404, "withdrawal-not-found", $"Could not find withdrawal ID {withdrawalId}.")
+    {
+        WithdrawalId = withdrawalId;
+    }
+}

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

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class WrongTradingPairException: CustodianApiException
+{
+    public const int HttpCode = 404;
+    public WrongTradingPairException(string fromAsset, string toAsset) : base(HttpCode, "wrong-trading-pair", $"Cannot find a trading pair for converting {fromAsset} into {toAsset}.")
+    {
+    }
+}

BTCPayServer.Abstractions/Custodians/Client/MarketTradeResult.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Abstractions.Custodians.Client;
+
+/**
+ * The result of a market trade. Used as a return type for custodians implementing ICanTrade
+ */
+public class MarketTradeResult
+{
+    public string FromAsset { get; }
+    public string ToAsset { get; }
+    /**
+     * The ledger entries that show the balances that were affected by the trade.
+     */
+    public List<LedgerEntryData> LedgerEntries { get; }
+    /**
+     * The unique ID of the trade that was executed.
+     */
+    public string TradeId { get; }
+
+    public MarketTradeResult(string fromAsset, string toAsset, List<LedgerEntryData> ledgerEntries, string tradeId)
+    {
+        this.FromAsset = fromAsset;
+        this.ToAsset = toAsset;
+        this.LedgerEntries = ledgerEntries;
+        this.TradeId = tradeId;
+    }
+}

BTCPayServer.Abstractions/Custodians/Client/WithdrawResult.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Abstractions.Custodians.Client;
+
+public class WithdrawResult
+{
+    public string PaymentMethod { get; }
+    public string Asset { get; set; }
+    public List<LedgerEntryData> LedgerEntries { get; }
+    public string WithdrawalId { get; }
+    public WithdrawalResponseData.WithdrawalStatus Status { get; }
+    public DateTimeOffset CreatedTime { get; }
+    public string TargetAddress { get; }
+    public string TransactionId { get; }
+
+    public WithdrawResult(string paymentMethod, string asset, List<LedgerEntryData> ledgerEntries, string withdrawalId, WithdrawalResponseData.WithdrawalStatus status, DateTimeOffset createdTime, string targetAddress, string transactionId)
+    {
+        PaymentMethod = paymentMethod;
+        Asset = asset;
+        LedgerEntries = ledgerEntries;
+        WithdrawalId = withdrawalId;
+        CreatedTime = createdTime;
+        Status = status;
+        TargetAddress = targetAddress;
+        TransactionId = transactionId;
+    }
+}

BTCPayServer.Abstractions/Custodians/ICanDeposit.cs

@@ -0,0 +1,17 @@
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+public interface ICanDeposit
+{
+    /**
+     * Get the address where we can deposit for the chosen payment method (crypto code + network).
+     * The result can be a string in different formats like a bitcoin address or even a LN invoice.
+     */
+    public Task<DepositAddressData> GetDepositAddressAsync(string paymentMethod, JObject config, CancellationToken cancellationToken);
+
+    public string[] GetDepositablePaymentMethods();
+}

BTCPayServer.Abstractions/Custodians/ICanTrade.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Custodians.Client;
+using BTCPayServer.Client.Models;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+public interface ICanTrade
+{
+
+    
+    /**
+     * A list of tradable asset pairs, or NULL if the custodian cannot trade/convert assets. if thr asset pair contains fiat, fiat is always put last. If both assets are a cyrptocode or both are fiat, the pair is written alphabetically. Always in uppercase. Example: ["BTC/EUR","BTC/USD", "EUR/USD", "BTC/ETH",...]
+     */
+    public List<AssetPairData> GetTradableAssetPairs();
+    
+    /**
+     * Execute a market order right now.
+     */
+    public Task<MarketTradeResult> TradeMarketAsync(string fromAsset, string toAsset, decimal qty, JObject config, CancellationToken cancellationToken);
+    
+    /**
+     * Get the details about a previous market trade.
+     */
+    public Task<MarketTradeResult> GetTradeInfoAsync(string tradeId, JObject config, CancellationToken cancellationToken);
+
+    public Task<AssetQuoteResult> GetQuoteForAssetAsync(string fromAsset, string toAsset, JObject config, CancellationToken cancellationToken);
+}
+
+
+

BTCPayServer.Abstractions/Custodians/ICanWithdraw.cs

@@ -0,0 +1,15 @@
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Custodians.Client;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+public interface ICanWithdraw
+{
+    public Task<WithdrawResult> WithdrawAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken);
+
+    public Task<WithdrawResult> GetWithdrawalInfoAsync(string paymentMethod, string withdrawalId, JObject config, CancellationToken cancellationToken);
+
+    public string[] GetWithdrawablePaymentMethods();
+}

BTCPayServer.Abstractions/Custodians/ICustodian.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+public interface ICustodian
+{
+    /**
+     * Get the unique code that identifies this custodian.
+     */
+    string Code { get; }
+    
+    string Name { get; }
+
+    /**
+     * Get a list of assets and their qty in custody.
+     */
+    Task<Dictionary<string, decimal>> GetAssetBalancesAsync(JObject config, CancellationToken cancellationToken);
+
+    public Task<Form.Form> GetConfigForm(JObject config, string locale,
+        CancellationToken cancellationToken = default);
+
+}

BTCPayServer.Abstractions/Extensions/CustodianExtensions.cs

@@ -0,0 +1,14 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using BTCPayServer.Abstractions.Custodians;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class CustodianExtensions
+{
+    public static ICustodian? GetCustodianByCode(this IEnumerable<ICustodian> custodians, string code)
+    {
+        return custodians.FirstOrDefault(custodian => custodian.Code == code);
+    }
+}

BTCPayServer.Abstractions/Extensions/Extensions.cs

@@ -1,20 +0,0 @@
-using System.Text.Json;
-using BTCPayServer.Abstractions.Models;
-using Microsoft.AspNetCore.Mvc.ViewFeatures;
-
-namespace BTCPayServer.Abstractions.Extensions
-{
-    public static class SetStatusMessageModelExtensions
-    {
-        public static void SetStatusMessageModel(this ITempDataDictionary tempData, StatusMessageModel statusMessage)
-        {
-            if (statusMessage == null)
-            {
-                tempData.Remove("StatusMessageModel");
-                return;
-            }
-
-            tempData["StatusMessageModel"] = JsonSerializer.Serialize(statusMessage, new JsonSerializerOptions());
-        }
-    }
-}

BTCPayServer.Abstractions/Extensions/GreenfieldExtensions.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using BTCPayServer.Client.Models;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class GreenfieldExtensions
+{
+    public static IActionResult CreateValidationError(this ControllerBase controller, ModelStateDictionary modelState)
+    {
+        return controller.UnprocessableEntity(modelState.ToGreenfieldValidationError());
+    }
+
+    public static List<GreenfieldValidationError> ToGreenfieldValidationError(this ModelStateDictionary modelState)
+    {
+        List<GreenfieldValidationError> errors = new List<GreenfieldValidationError>();
+        foreach (var error in modelState)
+        {
+            foreach (var errorMessage in error.Value.Errors)
+            {
+                errors.Add(new GreenfieldValidationError(error.Key, errorMessage.ErrorMessage));
+            }
+        }
+
+        return errors;
+    }
+
+    public static IActionResult CreateAPIError(this ControllerBase controller, string errorCode, string errorMessage)
+    {
+        return controller.BadRequest(new GreenfieldAPIError(errorCode, errorMessage));
+    }
+        
+    public static IActionResult CreateAPIError(this ControllerBase controller, int httpCode, string errorCode, string errorMessage)
+    {
+        return controller.StatusCode(httpCode, new GreenfieldAPIError(errorCode, errorMessage));
+    }
+        
+    public static IActionResult CreateAPIPermissionError(this ControllerBase controller, string missingPermission, string message = null)
+    {
+        return controller.StatusCode(403, new GreenfieldPermissionAPIError(missingPermission, message));
+    }
+}

BTCPayServer.Abstractions/Extensions/HttpRequestExtensions.cs

@@ -0,0 +1,120 @@
+using System;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class HttpRequestExtensions
+{
+    public static bool IsOnion(this HttpRequest request)
+    {
+        if (request?.Host.Host == null)
+            return false;
+        return request.Host.Host.EndsWith(".onion", StringComparison.OrdinalIgnoreCase);
+    }
+    
+    public static string GetAbsoluteRoot(this HttpRequest request)
+    {
+        return string.Concat(
+            request.Scheme,
+            "://",
+            request.Host.ToUriComponent(),
+            request.PathBase.ToUriComponent());
+    }
+
+    public static Uri GetAbsoluteRootUri(this HttpRequest request)
+    {
+        return new Uri(request.GetAbsoluteRoot());
+    }
+
+    public static string GetCurrentUrl(this HttpRequest request)
+    {
+        return string.Concat(
+            request.Scheme,
+            "://",
+            request.Host.ToUriComponent(),
+            request.PathBase.ToUriComponent(),
+            request.Path.ToUriComponent());
+    }
+
+    public static string GetCurrentPath(this HttpRequest request)
+    {
+        return string.Concat(
+            request.PathBase.ToUriComponent(),
+            request.Path.ToUriComponent());
+    }
+
+    public static string GetCurrentPathWithQueryString(this HttpRequest request)
+    {
+        return request.PathBase + request.Path + request.QueryString;
+    }
+
+    /// <summary>
+    /// If 'toto' and RootPath is 'rootpath' returns '/rootpath/toto'
+    /// If 'toto' and RootPath is empty returns '/toto'
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="path"></param>
+    /// <returns></returns>
+    public static string GetRelativePath(this HttpRequest request, string path)
+    {
+        if (path.Length > 0 && path[0] != '/')
+            path = $"/{path}";
+        return string.Concat(
+            request.PathBase.ToUriComponent(),
+            path);
+    }
+
+    /// <summary>
+    /// If 'https://example.com/toto' returns 'https://example.com/toto'
+    /// If 'toto' and RootPath is 'rootpath' returns '/rootpath/toto'
+    /// If 'toto' and RootPath is empty returns '/toto'
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="path"></param>
+    /// <returns></returns>
+    public static string GetRelativePathOrAbsolute(this HttpRequest request, string path)
+    {
+        if (!Uri.TryCreate(path, UriKind.RelativeOrAbsolute, out var uri) ||
+            uri.IsAbsoluteUri)
+            return path;
+
+        if (path.Length > 0 && path[0] != '/')
+            path = $"/{path}";
+        return string.Concat(
+            request.PathBase.ToUriComponent(),
+            path);
+    }
+
+    public static string GetAbsoluteUri(this HttpRequest request, string redirectUrl)
+    {
+        bool isRelative =
+            (redirectUrl.Length > 0 && redirectUrl[0] == '/')
+            || !new Uri(redirectUrl, UriKind.RelativeOrAbsolute).IsAbsoluteUri;
+        return isRelative ? request.GetAbsoluteRoot() + redirectUrl : redirectUrl;
+    }
+
+    /// <summary>
+    /// Will return an absolute URL. 
+    /// If `relativeOrAsbolute` is absolute, returns it.
+    /// If `relativeOrAsbolute` is relative, send absolute url based on the HOST of this request (without PathBase)
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="relativeOrAbsolte"></param>
+    /// <returns></returns>
+    public static Uri GetAbsoluteUriNoPathBase(this HttpRequest request, Uri relativeOrAbsolute = null)
+    {
+        if (relativeOrAbsolute == null)
+        {
+            return new Uri(string.Concat(
+                request.Scheme,
+                "://",
+                request.Host.ToUriComponent()), UriKind.Absolute);
+        }
+        if (relativeOrAbsolute.IsAbsoluteUri)
+            return relativeOrAbsolute;
+        return new Uri(string.Concat(
+            request.Scheme,
+            "://",
+            request.Host.ToUriComponent()) + relativeOrAbsolute.ToString().WithStartingSlash(), UriKind.Absolute);
+    }
+}

BTCPayServer.Abstractions/Extensions/ITempDataDictionaryExtensions.cs

@@ -0,0 +1,59 @@
+using System.Text.Json;
+using BTCPayServer.Abstractions.Constants;
+using BTCPayServer.Abstractions.Models;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class SetStatusMessageModelExtensions
+{
+    public static void SetStatusMessageModel(this ITempDataDictionary tempData, StatusMessageModel statusMessage)
+    {
+        if (statusMessage == null)
+        {
+            tempData.Remove("StatusMessageModel");
+            return;
+        }
+
+        tempData["StatusMessageModel"] = JsonSerializer.Serialize(statusMessage, new JsonSerializerOptions());
+    }
+
+    public static StatusMessageModel GetStatusMessageModel(this ITempDataDictionary tempData)
+    {
+        tempData.TryGetValue(WellKnownTempData.SuccessMessage, out var successMessage);
+        tempData.TryGetValue(WellKnownTempData.ErrorMessage, out var errorMessage);
+        tempData.TryGetValue("StatusMessageModel", out var model);
+        if (successMessage != null || errorMessage != null)
+        {
+            var parsedModel = new StatusMessageModel();
+            parsedModel.Message = (string)successMessage ?? (string)errorMessage;
+            if (successMessage != null)
+            {
+                parsedModel.Severity = StatusMessageModel.StatusSeverity.Success;
+            }
+            else
+            {
+                parsedModel.Severity = StatusMessageModel.StatusSeverity.Error;
+            }
+            return parsedModel;
+        }
+        else if (model != null && model is string str)
+        {
+            return JObject.Parse(str).ToObject<StatusMessageModel>();
+        }
+        return null;
+    }
+
+    public static bool HasStatusMessage(this ITempDataDictionary tempData)
+    {
+        return (tempData.Peek(WellKnownTempData.SuccessMessage) ??
+                tempData.Peek(WellKnownTempData.ErrorMessage) ??
+                tempData.Peek("StatusMessageModel")) != null;
+    }
+
+    public static bool HasErrorMessage(this ITempDataDictionary tempData)
+    {
+        return GetStatusMessageModel(tempData)?.Severity == StatusMessageModel.StatusSeverity.Error;
+    }
+}

BTCPayServer.Abstractions/Extensions/StringExtensions.cs

@@ -0,0 +1,45 @@
+using System;
+using System.IO;
+using System.Linq;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class StringExtensions
+{
+
+    public static bool IsValidFileName(this string fileName)
+    {
+        return !fileName.ToCharArray().Any(c => Path.GetInvalidFileNameChars().Contains(c)
+                                                || c == Path.AltDirectorySeparatorChar
+                                                || c == Path.DirectorySeparatorChar
+                                                || c == Path.PathSeparator
+                                                || c == '\\');
+    }
+
+    public static string Truncate(this string value, int maxLength)
+    {
+        if (string.IsNullOrEmpty(value))
+            return value;
+        return value.Length <= maxLength ? value : value.Substring(0, maxLength);
+    }
+
+    public static string WithTrailingSlash(this string str)
+    {
+        if (str.EndsWith("/", StringComparison.InvariantCulture))
+            return str;
+        return str + "/";
+    }
+    public static string WithStartingSlash(this string str)
+    {
+        if (str.StartsWith("/", StringComparison.InvariantCulture))
+            return str;
+        return $"/{str}";
+    }
+    public static string WithoutEndingSlash(this string str)
+    {
+        if (str.EndsWith("/", StringComparison.InvariantCulture))
+            return str.Substring(0, str.Length - 1);
+        return str;
+    }
+    
+}

BTCPayServer.Abstractions/Extensions/ViewsRazor.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Globalization;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+
+namespace BTCPayServer.Abstractions.Extensions
+{
+    public static class ViewsRazor
+    {
+        private const string ACTIVE_CATEGORY_KEY = "ActiveCategory";
+        private const string ACTIVE_PAGE_KEY = "ActivePage";
+        private const string ACTIVE_ID_KEY = "ActiveId";
+
+        public static void SetActivePage<T>(this ViewDataDictionary viewData, T activePage, string title = null, string activeId = null)
+            where T : IConvertible
+        {
+            SetActivePage(viewData, activePage.ToString(), activePage.GetType().ToString(), title, activeId);
+        }
+
+        public static void SetActivePage(this ViewDataDictionary viewData, string activePage, string category, string title = null, string activeId = null)
+        {
+            // Page Title
+            viewData["Title"] = title ?? activePage;
+            // Navigation
+            viewData[ACTIVE_PAGE_KEY] = activePage;
+            viewData[ACTIVE_ID_KEY] = activeId;
+            SetActiveCategory(viewData, category);
+        }
+
+        public static void SetActiveCategory<T>(this ViewDataDictionary viewData, T activeCategory)
+        {
+            SetActiveCategory(viewData, activeCategory.ToString());
+        }
+
+        public static void SetActiveCategory(this ViewDataDictionary viewData, string activeCategory)
+        {
+            viewData[ACTIVE_CATEGORY_KEY] = activeCategory;
+        }
+
+        public static string IsActiveCategory<T>(this ViewDataDictionary viewData, T category, object id = null)
+        {
+            return IsActiveCategory(viewData, category.ToString(), id);
+        }
+        
+        public static string IsActiveCategory(this ViewDataDictionary viewData, string category, object id = null)
+        {
+            if (!viewData.ContainsKey(ACTIVE_CATEGORY_KEY))
+            {
+                return null;
+            }
+            var activeId = viewData[ACTIVE_ID_KEY];
+            var activeCategory = viewData[ACTIVE_CATEGORY_KEY]?.ToString();
+            var categoryMatch = category.Equals(activeCategory, StringComparison.InvariantCultureIgnoreCase);
+            var idMatch = id == null || activeId == null || id.Equals(activeId);
+            return categoryMatch && idMatch ? "active" : null;
+        }
+
+        public static string IsActivePage<T>(this ViewDataDictionary viewData, T page, object id = null)
+            where T : IConvertible
+        {
+            return IsActivePage(viewData, page.ToString(), page.GetType().ToString(), id);
+        }
+        
+        public static string IsActivePage(this ViewDataDictionary viewData, string page, string category, object id = null)
+        {
+            if (!viewData.ContainsKey(ACTIVE_PAGE_KEY))
+            {
+                return null;
+            }
+            var activeId = viewData[ACTIVE_ID_KEY];
+            var activePage = viewData[ACTIVE_PAGE_KEY]?.ToString();
+            var activeCategory = viewData[ACTIVE_CATEGORY_KEY]?.ToString();
+            var categoryAndPageMatch = (category == null || activeCategory.Equals(category, StringComparison.InvariantCultureIgnoreCase)) && page.Equals(activePage, StringComparison.InvariantCultureIgnoreCase);
+            var idMatch = id == null || activeId == null || id.Equals(activeId);
+            return categoryAndPageMatch && idMatch ? "active" : null;
+        }
+
+        public static HtmlString ToBrowserDate(this DateTimeOffset date)
+        {
+            var displayDate = date.ToString("o", CultureInfo.InvariantCulture);
+            return new HtmlString($"<span class='localizeDate'>{displayDate}</span>");
+        }
+
+        public static HtmlString ToBrowserDate(this DateTime date)
+        {
+            var displayDate = date.ToString("o", CultureInfo.InvariantCulture);
+            return new HtmlString($"<span class='localizeDate'>{displayDate}</span>");
+        }
+
+        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 TimeString(this TimeSpan timeSpan)
+        {
+            if (timeSpan.TotalMinutes < 1)
+            {
+                return $"{(int)timeSpan.TotalSeconds} second{Plural((int)timeSpan.TotalSeconds)}";
+            }
+            if (timeSpan.TotalHours < 1)
+            {
+                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)}";
+        }
+
+        private static string Plural(int value)
+        {
+            return value > 1 ? "s" : string.Empty;
+        }
+    }
+}

BTCPayServer.Abstractions/Form/AlertMessage.cs

@@ -0,0 +1,37 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public class AlertMessage
+{
+    // Corresponds to the Bootstrap CSS "alert alert-xxx" messages:
+    // Success = green
+    // Warning = orange
+    // Danger = red
+    // Info = blue
+    public enum AlertMessageType
+    {
+        Success,
+        Warning,
+        Danger,
+        Info
+    }
+    
+    [JsonConverter(typeof(StringEnumConverter))]
+    public AlertMessageType Type;
+    
+    // The translated message to be shown to the user
+    public string Message;
+
+    public AlertMessage()
+    {
+        
+    }
+
+    public AlertMessage(AlertMessageType type, string message)
+    {
+        this.Type = type;
+        this.Message = message;
+    }
+}

BTCPayServer.Abstractions/Form/Field.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public abstract 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;
+    
+    // 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()
+    {
+        return ValidationErrors.Count == 0;
+    }
+}

BTCPayServer.Abstractions/Form/Fieldset.cs

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

BTCPayServer.Abstractions/Form/Form.cs

@@ -0,0 +1,60 @@
+using System.Collections.Generic;
+
+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();
+    
+
+    // 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;
+    }
+
+    public Field GetFieldByName(string name)
+    {
+        foreach (var fieldset in Fieldsets)
+        {
+            foreach (var field in fieldset.Fields)
+            {
+                if (name.Equals(field.Name))
+                {
+                    return field;
+                }
+            }
+        }
+        return null;
+    }
+
+    public List<string> GetAllNames()
+    {
+        var names = new List<string>();
+        foreach (var fieldset in Fieldsets)
+        {
+            foreach (var field in fieldset.Fields)
+            {
+                names.Add(field.Name);
+            }
+        }
+
+        return names;
+    }
+}

BTCPayServer.Abstractions/Form/TextField.cs

@@ -0,0 +1,19 @@
+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.Abstractions/Models/BaseBTCPayServerPlugin.cs

@@ -21,7 +21,6 @@ namespace BTCPayServer.Abstractions.Models
 
         public abstract string Description { get; }
         public bool SystemPlugin { get; set; }
-        public bool SystemExtension { get; set; }
         public virtual IBTCPayServerPlugin.PluginDependency[] Dependencies { get; } = Array.Empty<IBTCPayServerPlugin.PluginDependency>();
 
         public virtual void Execute(IApplicationBuilder applicationBuilder,

BTCPayServer.Abstractions/Models/ConfirmModel.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace BTCPayServer.Abstractions.Models
+{
+    public class ConfirmModel
+    {
+        private const string ButtonClassDefault = "btn-danger";
+
+        public ConfirmModel() { }
+
+        public ConfirmModel(string title, string desc, string action = null, string buttonClass = ButtonClassDefault, string actionName = null, string controllerName = null)
+        {
+            Title = title;
+            Description = desc;
+            Action = action;
+            ActionName = actionName;
+            ControllerName = controllerName;
+            ButtonClass = buttonClass;
+
+            if (Description.Contains("<strong>", StringComparison.InvariantCultureIgnoreCase))
+            {
+                DescriptionHtml = true;
+            }
+        }
+
+        public string Title { get; set; }
+        public string Description { get; set; }
+        public bool DescriptionHtml { get; set; }
+        public string Action { get; set; }
+        public string ActionName { get; set; }
+        public string ControllerName { get; set; }
+        public string ButtonClass { get; set; } = ButtonClassDefault;
+    }
+}

BTCPayServer.Abstractions/Models/DatabaseOptions.cs

@@ -2,12 +2,6 @@ namespace BTCPayServer.Abstractions.Models
 {
     public class DatabaseOptions
     {
-        public DatabaseOptions(DatabaseType type, string connString)
-        {
-            DatabaseType = type;
-            ConnectionString = connString;
-        }
-
         public DatabaseType DatabaseType { get; set; }
         public string ConnectionString { get; set; }
     }

BTCPayServer.Abstractions/Security/AuthorizationFilterHandle.cs

@@ -0,0 +1,27 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.Security;
+
+public class AuthorizationFilterHandle
+{
+    public AuthorizationHandlerContext Context { get; }
+    public PolicyRequirement Requirement { get; }
+    public HttpContext HttpContext { get; }
+    public bool Success { get; private set;  }
+
+    public AuthorizationFilterHandle(
+        AuthorizationHandlerContext context,
+        PolicyRequirement requirement,
+        HttpContext httpContext)
+    {
+        Context = context;
+        Requirement = requirement;
+        HttpContext = httpContext;
+    }
+
+    public void MarkSuccessful()
+    {
+        Success = true;
+    }
+}

BTCPayServer.Abstractions/Security/ContentSecurityPolicies.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using NBitcoin.Crypto;
 
 namespace BTCPayServer.Security
 {
@@ -9,6 +10,8 @@ namespace BTCPayServer.Security
     {
         public ConsentSecurityPolicy(string name, string value)
         {
+            if (value.Contains(';', StringComparison.OrdinalIgnoreCase))
+                throw new FormatException();
             _Value = value;
             _Name = name;
         }
@@ -67,10 +70,47 @@ namespace BTCPayServer.Security
         }
 
         readonly HashSet<ConsentSecurityPolicy> _Policies = new HashSet<ConsentSecurityPolicy>();
+
+        /// <summary>
+        /// Allow a specific script as event handler
+        /// </summary>
+        /// <param name="script"></param>
+        public void AllowUnsafeHashes(string script = null)
+        {
+            if (!allowUnsafeHashes)
+            {
+                Add("script-src", $"'unsafe-hashes'");
+                allowUnsafeHashes = true;
+            }
+            if (script != null)
+            {
+                var sha = GetSha256(script);
+                Add("script-src", $"'sha256-{sha}'");
+            }
+        }
+
+        bool allowUnsafeHashes = false;
+        /// <summary>
+        /// Allow the injection of script tag with the following script
+        /// </summary>
+        /// <param name="script"></param>
+        public void AllowInline(string script)
+        {
+            ArgumentNullException.ThrowIfNull(script);
+            var sha = GetSha256(script);
+            Add("script-src", $"'sha256-{sha}'");
+        }
+        static string GetSha256(string script)
+        {
+            return Convert.ToBase64String(Hashes.SHA256(Encoding.UTF8.GetBytes(script.Replace("\r\n", "\n", StringComparison.Ordinal))));
+        }
+
+        public void Add(string name, string value)
+        {
+            Add(new ConsentSecurityPolicy(name, value));
+        }
         public void Add(ConsentSecurityPolicy policy)
         {
-            if (_Policies.Any(p => p.Name == policy.Name && p.Value == policy.Name))
-                return;
             _Policies.Add(policy);
         }
 
@@ -87,34 +127,19 @@ namespace BTCPayServer.Security
                 {
                     value.Append(';');
                 }
-                List<string> values = new List<string>();
+                HashSet<string> values = new HashSet<string>();
+                List<string> valuesList = new List<string>();
                 values.Add(group.Key);
+                valuesList.Add(group.Key);
                 foreach (var v in group)
                 {
-                    values.Add(v.Value);
+                    if (values.Add(v.Value))
+                        valuesList.Add(v.Value);
                 }
-                foreach (var i in authorized)
-                {
-                    values.Add(i);
-                }
-                value.Append(String.Join(" ", values.OfType<object>().ToArray()));
+                value.Append(String.Join(" ", valuesList.OfType<object>().ToArray()));
                 firstGroup = false;
             }
             return value.ToString();
         }
-
-        internal void Clear()
-        {
-            authorized.Clear();
-            _Policies.Clear();
-        }
-
-        readonly HashSet<string> authorized = new HashSet<string>();
-        internal void AddAllAuthorized(string v)
-        {
-            authorized.Add(v);
-        }
-
-        public IEnumerable<string> Authorized => authorized;
     }
 }

BTCPayServer.Abstractions/Security/PolicyRequirement.cs

@@ -7,8 +7,7 @@ namespace BTCPayServer.Security
     {
         public PolicyRequirement(string policy)
         {
-            if (policy == null)
-                throw new ArgumentNullException(nameof(policy));
+            ArgumentNullException.ThrowIfNull(policy);
             Policy = policy;
         }
         public string Policy { get; }

BTCPayServer.Abstractions/Services/PluginAction.cs

@@ -3,9 +3,9 @@ using BTCPayServer.Abstractions.Contracts;
 
 namespace BTCPayServer.Abstractions.Services
 {
-    public abstract class PluginAction<T>:IPluginHookAction
+    public abstract class PluginAction<T> : IPluginHookAction
     {
-        public string Hook { get; }
+        public abstract string Hook { get; }
         public Task Execute(object args)
         {
             return Execute(args is T args1 ? args1 : default);

BTCPayServer.Abstractions/Services/PluginHookFilter.cs

@@ -3,9 +3,10 @@ using BTCPayServer.Abstractions.Contracts;
 
 namespace BTCPayServer.Abstractions.Services
 {
-    public abstract class PluginHookFilter<T>:IPluginHookFilter
+    public abstract class PluginHookFilter<T> : IPluginHookFilter
     {
-        public string Hook { get; }
+        public abstract string Hook { get; }
+
         public Task<object> Execute(object args)
         {
             return Execute(args is T args1 ? args1 : default).ContinueWith(task => task.Result as object);

BTCPayServer.Abstractions/Services/Safe.cs

@@ -2,7 +2,7 @@ using Ganss.XSS;
 using Microsoft.AspNetCore.Html;
 using Microsoft.AspNetCore.Mvc.Rendering;
 
-namespace BTCPayServer.Services
+namespace BTCPayServer.Abstractions.Services
 {
     public class Safe
     {

BTCPayServer.Abstractions/Services/UIExtension.cs

@@ -2,7 +2,7 @@ using BTCPayServer.Abstractions.Contracts;
 
 namespace BTCPayServer.Abstractions.Services
 {
-    public class UIExtension: IUIExtension
+    public class UIExtension : IUIExtension
     {
         public UIExtension(string partial, string location)
         {

BTCPayServer.Abstractions/TagHelpers/CSPA.cs

@@ -0,0 +1,30 @@
+using System;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+/// <summary>
+/// Add sha256- to allow inline event handlers in a:href=javascript:
+/// </summary>
+[HtmlTargetElement("a", Attributes = "csp-allow")]
+public class CSPA : TagHelper
+{
+    private readonly ContentSecurityPolicies _csp;
+    public CSPA(ContentSecurityPolicies csp)
+    {
+        _csp = csp;
+    }
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        output.Attributes.RemoveAll("csp-allow");
+        if (output.Attributes.TryGetAttribute("href", out var attr))
+        {
+            var v = attr.Value.ToString();
+            if (v.StartsWith("javascript:", StringComparison.OrdinalIgnoreCase))
+            {
+                _csp.AllowUnsafeHashes(v);
+            }
+        }
+    }
+}

BTCPayServer.Abstractions/TagHelpers/CSPEventTagHelper.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Linq;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+/// <summary>
+/// Add 'unsafe-hashes' and sha256- to allow inline event handlers in CSP
+/// </summary>
+[HtmlTargetElement(Attributes = "onclick")]
+[HtmlTargetElement(Attributes = "onkeypress")]
+[HtmlTargetElement(Attributes = "onchange")]
+[HtmlTargetElement(Attributes = "onsubmit")]
+public class CSPEventTagHelper : TagHelper
+{
+    public const string EventNames = "onclick,onkeypress,onchange,onsubmit";
+    private readonly ContentSecurityPolicies _csp;
+
+    readonly static HashSet<string> EventSet = EventNames.Split(',')
+                                                .ToHashSet();
+    public CSPEventTagHelper(ContentSecurityPolicies csp)
+    {
+        _csp = csp;
+    }
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        foreach (var attr in output.Attributes)
+        {
+            var n = attr.Name.ToLowerInvariant();
+            if (EventSet.Contains(n))
+            {
+                _csp.AllowUnsafeHashes(attr.Value.ToString());
+            }
+        }
+    }
+}

BTCPayServer.Abstractions/TagHelpers/CSPInlineScriptTagHelper.cs

@@ -0,0 +1,33 @@
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+using NBitcoin;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+/// <summary>
+/// Add a nonce-* so the inline-script can pass CSP rule when they are rendered server-side
+/// </summary>
+[HtmlTargetElement("script")]
+public class CSPInlineScriptTagHelper : TagHelper
+{
+    private readonly ContentSecurityPolicies _csp;
+
+    public CSPInlineScriptTagHelper(ContentSecurityPolicies csp)
+    {
+        _csp = csp;
+    }
+
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        if (output.Attributes.ContainsName("src"))
+            return;
+        if (output.Attributes.TryGetAttribute("type", out var attr))
+        {
+            if (attr.Value?.ToString() != "text/javascript")
+                return;
+        }
+        var nonce = RandomUtils.GetUInt256().ToString().Substring(0, 32);
+        output.Attributes.Add(new TagHelperAttribute("nonce", nonce));
+        _csp.Add("script-src", $"'nonce-{nonce}'");
+    }
+}

BTCPayServer.Abstractions/TagHelpers/CSPTemplate.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+/// <summary>
+/// Add sha256- to allow inline event handlers in CSP
+/// </summary>
+[HtmlTargetElement("template", Attributes = "csp-allow")]
+public class CSPTemplate : TagHelper
+{
+    private readonly ContentSecurityPolicies _csp;
+    public CSPTemplate(ContentSecurityPolicies csp)
+    {
+        _csp = csp;
+    }
+    public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
+    {
+        output.Attributes.RemoveAll("csp-allow");
+        var childContent = await output.GetChildContentAsync();
+        var content = childContent.GetContent();
+        _csp.AllowInline(content);
+    }
+}

BTCPayServer.Abstractions/TagHelpers/PermissionTagHelper.cs

@@ -0,0 +1,48 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+using Microsoft.Extensions.Logging;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+[HtmlTargetElement(Attributes = nameof(Permission))]
+public class PermissionTagHelper : TagHelper
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly ILogger<PermissionTagHelper> _logger;
+
+    public PermissionTagHelper(IAuthorizationService authorizationService, IHttpContextAccessor httpContextAccessor, ILogger<PermissionTagHelper> logger)
+    {
+        _authorizationService = authorizationService;
+        _httpContextAccessor = httpContextAccessor;
+        _logger = logger;
+    }
+
+    public string Permission { get; set; }
+    public string PermissionResource { get; set; }
+
+    public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
+    {
+        if (string.IsNullOrEmpty(Permission))
+            return;
+        if (_httpContextAccessor.HttpContext is null)
+            return;
+
+        var key = $"{Permission}_{PermissionResource}";
+        if (!_httpContextAccessor.HttpContext.Items.TryGetValue(key, out var o) ||
+            o is not AuthorizationResult res)
+        {
+            res = await _authorizationService.AuthorizeAsync(_httpContextAccessor.HttpContext.User,
+                PermissionResource,
+                Permission);
+            _httpContextAccessor.HttpContext.Items.Add(key, res);
+        }
+        if (!res.Succeeded)
+        {
+            output.SuppressOutput();
+        }
+
+    }
+}

BTCPayServer.Abstractions/TagHelpers/SVGUse.cs

@@ -0,0 +1,25 @@
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Mvc.Razor.TagHelpers;
+using Microsoft.AspNetCore.Mvc.Routing;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+// Make sure that <svg><use href=/ are correctly working if rootpath is present
+[HtmlTargetElement("use", Attributes = "href")]
+public class SVGUse : UrlResolutionTagHelper
+{
+    private readonly IFileVersionProvider _fileVersionProvider;
+
+    public SVGUse(IUrlHelperFactory urlHelperFactory, HtmlEncoder htmlEncoder, IFileVersionProvider fileVersionProvider) : base(urlHelperFactory, htmlEncoder)
+    {
+        _fileVersionProvider = fileVersionProvider;
+    }
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        var attr = output.Attributes["href"].Value.ToString();
+        attr = _fileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, attr);
+        output.Attributes.SetAttribute("href", attr);
+    }
+}

BTCPayServer.Abstractions/TagHelpers/SrvModel.cs

@@ -0,0 +1,31 @@
+using BTCPayServer.Abstractions.Services;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+using NBitcoin;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+[HtmlTargetElement("srv-model")]
+public class SrvModel : TagHelper
+{
+    private readonly Safe _safe;
+    private readonly ContentSecurityPolicies _csp;
+
+    public SrvModel(Safe safe, ContentSecurityPolicies csp)
+    {
+        _safe = safe;
+        _csp = csp;
+    }
+    public string VarName { get; set; } = "srvModel";
+    public object Model { get; set; }
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        output.TagName = "script";
+        output.TagMode = TagMode.StartTagAndEndTag;
+        output.Attributes.Add(new TagHelperAttribute("type", "text/javascript"));
+        var nonce = RandomUtils.GetUInt256().ToString().Substring(0, 32);
+        output.Attributes.Add(new TagHelperAttribute("nonce", nonce));
+        _csp.Add("script-src", $"'nonce-{nonce}'");
+        output.Content.SetHtmlContent($"var {VarName} = {_safe.Json(Model)};");
+    }
+}

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -2,6 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>netstandard2.1</TargetFramework>
+        <LangVersion>10.0</LangVersion>
         <Company>BTCPay Server</Company>
         <Copyright>Copyright © BTCPay Server 2020</Copyright>
         <Description>A client library for BTCPay Server Greenfield API</Description>
@@ -13,7 +14,7 @@
         <RepositoryType>git</RepositoryType>
     </PropertyGroup>
   <PropertyGroup>
-    <Version Condition=" '$(Version)' == '' ">1.2.0</Version>
+    <Version Condition=" '$(Version)' == '' ">1.7.0</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -27,9 +28,9 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="NBitcoin" Version="5.0.60" />
-      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.2.0" />
-      <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.3.8" />
+      <PackageReference Include="NBitcoin" Version="7.0.10" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     </ItemGroup>
   <ItemGroup>
     <None Include="icon.png" Pack="true" PackagePath="\" />

BTCPayServer.Client/BTCPayServerClient.Apps.cs

@@ -0,0 +1,43 @@
+using System;
+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<PointOfSaleAppData> CreatePointOfSaleApp(string storeId,
+            CreatePointOfSaleAppRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/apps/pos", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<PointOfSaleAppData>(response);
+        }
+
+        public virtual async Task<AppDataBase> GetApp(string appId, CancellationToken token = default)
+        {
+            if (appId == null)
+                throw new ArgumentNullException(nameof(appId));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/apps/{appId}",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<AppDataBase>(response);
+        }
+
+        public virtual async Task DeleteApp(string appId, CancellationToken token = default)
+        {
+            if (appId == null)
+                throw new ArgumentNullException(nameof(appId));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/apps/{appId}",
+                    method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.CustodianAccounts.cs

@@ -0,0 +1,97 @@
+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<IEnumerable<CustodianAccountData>> GetCustodianAccounts(string storeId, bool includeAssetBalances = false, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (includeAssetBalances)
+            {
+                queryPayload.Add("assetBalances", "true");
+            }
+
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts", queryPayload), token);
+            return await HandleResponse<IEnumerable<CustodianAccountData>>(response);
+        }
+
+        public virtual async Task<CustodianAccountResponse> GetCustodianAccount(string storeId, string accountId, bool includeAssetBalances = false, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (includeAssetBalances)
+            {
+                queryPayload.Add("assetBalances", "true");
+            }
+
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", queryPayload), token);
+            return await HandleResponse<CustodianAccountResponse>(response);
+        }
+
+        public virtual async Task<CustodianAccountData> CreateCustodianAccount(string storeId, CreateCustodianAccountRequest request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts", bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<CustodianAccountData>(response);
+        }
+
+        public virtual async Task<CustodianAccountData> UpdateCustodianAccount(string storeId, string accountId, CreateCustodianAccountRequest request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", bodyPayload: request, method: HttpMethod.Put), token);
+            return await HandleResponse<CustodianAccountData>(response);
+        }
+
+        public virtual async Task DeleteCustodianAccount(string storeId, string accountId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<DepositAddressData> GetDepositAddress(string storeId, string accountId, string paymentMethod, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/addresses/{paymentMethod}"), token);
+            return await HandleResponse<DepositAddressData>(response);
+        }
+
+        public virtual async Task<MarketTradeResponseData> MarketTradeCustodianAccountAsset(string storeId, string accountId, TradeRequestData request, CancellationToken token = default)
+        {
+            
+            //var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/users", null, request, HttpMethod.Post), token);
+            //return await HandleResponse<ApplicationUserData>(response);
+            var internalRequest = CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/market", null,
+                    request, HttpMethod.Post);
+            var response = await _httpClient.SendAsync(internalRequest, token);
+            return await HandleResponse<MarketTradeResponseData>(response);
+        }
+
+        public virtual async Task<MarketTradeResponseData> GetTradeInfo(string storeId, string accountId, string tradeId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/{tradeId}", method: HttpMethod.Get), token);
+            return await HandleResponse<MarketTradeResponseData>(response);
+        }
+
+        public virtual async Task<TradeQuoteResponseData> GetTradeQuote(string storeId, string accountId, string fromAsset, string toAsset, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            queryPayload.Add("fromAsset", fromAsset);
+            queryPayload.Add("toAsset", toAsset);
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/quote", queryPayload), token);
+            return await HandleResponse<TradeQuoteResponseData>(response);
+        }
+        
+        public virtual async Task<WithdrawalResponseData> CreateWithdrawal(string storeId, string accountId,  WithdrawRequestData request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals", bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<WithdrawalResponseData>(response);
+        }
+
+        public virtual async Task<WithdrawalResponseData> GetWithdrawalInfo(string storeId, string accountId, string paymentMethod, string withdrawalId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals/{paymentMethod}/{withdrawalId}", method: HttpMethod.Get), token);
+            return await HandleResponse<WithdrawalResponseData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Custodians.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<IEnumerable<CustodianData>> GetCustodians(CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/custodians"), token);
+            return await HandleResponse<IEnumerable<CustodianData>>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Invoices.cs

@@ -1,21 +1,56 @@
 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<IEnumerable<InvoiceData>> GetInvoices(string storeId, bool includeArchived = false,
+        public virtual async Task<IEnumerable<InvoiceData>> GetInvoices(string storeId, string[] orderId = null,
+            InvoiceStatus[] status = null,
+            DateTimeOffset? startDate = null,
+            DateTimeOffset? endDate = null,
+            string textSearch = null,
+            bool includeArchived = false,
+            int? skip = null,
+            int? take = null,
             CancellationToken token = default)
         {
+            Dictionary<string, object> queryPayload = new Dictionary<string, object>();
+            queryPayload.Add(nameof(includeArchived), includeArchived);
+
+            if (startDate is DateTimeOffset s)
+                queryPayload.Add(nameof(startDate), Utils.DateTimeToUnixTime(s));
+
+            if (endDate is DateTimeOffset e)
+                queryPayload.Add(nameof(endDate), Utils.DateTimeToUnixTime(e));
+
+            if (orderId != null)
+                queryPayload.Add(nameof(orderId), orderId);
+            if (textSearch != null)
+                queryPayload.Add(nameof(textSearch), textSearch);
+            if (status != null)
+                queryPayload.Add(nameof(status), status.Select(s => s.ToString().ToLower()).ToArray());
+
+            if (skip != null)
+            {
+                queryPayload.Add(nameof(skip), skip);
+            }
+
+            if (take != null)
+            {
+                queryPayload.Add(nameof(take), take);
+            }
+
             var response =
                 await _httpClient.SendAsync(
                     CreateHttpRequest($"api/v1/stores/{storeId}/invoices",
-                        new Dictionary<string, object>() {{nameof(includeArchived), includeArchived}}), token);
+                        queryPayload), token);
             return await HandleResponse<IEnumerable<InvoiceData>>(response);
         }
 
@@ -54,12 +89,23 @@ namespace BTCPayServer.Client
             return await HandleResponse<InvoiceData>(response);
         }
 
+        public virtual async Task<InvoiceData> UpdateInvoice(string storeId, string invoiceId,
+            UpdateInvoiceRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}", bodyPayload: request,
+                    method: HttpMethod.Put), token);
+            return await HandleResponse<InvoiceData>(response);
+        }
+
         public virtual async Task<InvoiceData> MarkInvoiceStatus(string storeId, string invoiceId,
             MarkInvoiceStatusRequest request, CancellationToken token = default)
         {
             if (request == null)
                 throw new ArgumentNullException(nameof(request));
-            if (request.Status!= InvoiceStatus.Settled && request.Status!= InvoiceStatus.Invalid)
+            if (request.Status != InvoiceStatus.Settled && request.Status != InvoiceStatus.Invalid)
                 throw new ArgumentOutOfRangeException(nameof(request.Status), "Status can only be Invalid or Complete");
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/status", bodyPayload: request,
@@ -70,9 +116,17 @@ namespace BTCPayServer.Client
         public virtual async Task<InvoiceData> UnarchiveInvoice(string storeId, string invoiceId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/unarchive", 
+                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/unarchive",
                     method: HttpMethod.Post), token);
             return await HandleResponse<InvoiceData>(response);
         }
+
+        public virtual async Task ActivateInvoicePaymentMethod(string storeId, string invoiceId, string paymentMethod, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/payment-methods/{paymentMethod}/activate",
+                    method: HttpMethod.Post), token);
+            await HandleResponse(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.LNURLPayPaymentMethods.cs

@@ -0,0 +1,59 @@
+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<IEnumerable<LNURLPayPaymentMethodData>>
+            GetStoreLNURLPayPaymentMethods(string storeId, bool? enabled = null,
+                CancellationToken token = default)
+        {
+            var query = new Dictionary<string, object>();
+            if (enabled != null)
+            {
+                query.Add(nameof(enabled), enabled);
+            }
+
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay",
+                        query), token);
+            return await HandleResponse<IEnumerable<LNURLPayPaymentMethodData>>(response);
+        }
+
+        public virtual async Task<LNURLPayPaymentMethodData> GetStoreLNURLPayPaymentMethod(
+            string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}"), token);
+            return await HandleResponse<LNURLPayPaymentMethodData>(response);
+        }
+
+        public virtual async Task RemoveStoreLNURLPayPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}",
+                        method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<LNURLPayPaymentMethodData> UpdateStoreLNURLPayPaymentMethod(
+            string storeId,
+            string cryptoCode, LNURLPayPaymentMethodData paymentMethod,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}",
+                    bodyPayload: paymentMethod, method: HttpMethod.Put), token);
+            return await HandleResponse<LNURLPayPaymentMethodData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -9,7 +9,7 @@ namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
+        public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -17,8 +17,17 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Get), token);
             return await HandleResponse<LightningNodeInformationData>(response);
         }
+        
+        public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/balance",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeBalanceData>(response);
+        }
 
-        public async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
+        public virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -29,7 +38,7 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string cryptoCode,
+        public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -38,24 +47,23 @@ namespace BTCPayServer.Client
             return await HandleResponse<IEnumerable<LightningChannelData>>(response);
         }
 
-        public async Task<string> OpenLightningChannel(string cryptoCode, OpenLightningChannelRequest request,
+        public virtual async Task OpenLightningChannel(string cryptoCode, OpenLightningChannelRequest request,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/channels", bodyPayload: request,
                     method: HttpMethod.Post), token);
-            return await HandleResponse<string>(response);
+            await HandleResponse(response);
         }
 
-        public async Task<string> GetLightningDepositAddress(string cryptoCode, CancellationToken token = default)
+        public virtual async Task<string> GetLightningDepositAddress(string cryptoCode, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/address", method: HttpMethod.Post), token);
             return await HandleResponse<string>(response);
         }
 
-
-        public async Task PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
+        public virtual async Task<LightningPaymentData> PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -63,10 +71,21 @@ namespace BTCPayServer.Client
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices/pay", bodyPayload: request,
                     method: HttpMethod.Post), token);
-            await HandleResponse(response);
+            return await HandleResponse<LightningPaymentData>(response);
         }
 
-        public async Task<LightningInvoiceData> GetLightningInvoice(string cryptoCode,
+        public virtual async Task<LightningPaymentData> GetLightningPayment(string cryptoCode,
+            string paymentHash, CancellationToken token = default)
+        {
+            if (paymentHash == null)
+                throw new ArgumentNullException(nameof(paymentHash));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/payments/{paymentHash}",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningPaymentData>(response);
+        }
+
+        public virtual async Task<LightningInvoiceData> GetLightningInvoice(string cryptoCode,
             string invoiceId, CancellationToken token = default)
         {
             if (invoiceId == null)
@@ -77,7 +96,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<LightningInvoiceData>(response);
         }
 
-        public async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
+        public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
             CancellationToken token = default)
         {
             if (request == null)

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -9,7 +9,7 @@ namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
+        public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -17,8 +17,17 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Get), token);
             return await HandleResponse<LightningNodeInformationData>(response);
         }
+        
+        public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string storeId, string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/balance",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeBalanceData>(response);
+        }
 
-        public async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
+        public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -29,7 +38,7 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string storeId, string cryptoCode,
+        public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string storeId, string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -38,16 +47,16 @@ namespace BTCPayServer.Client
             return await HandleResponse<IEnumerable<LightningChannelData>>(response);
         }
 
-        public async Task<string> OpenLightningChannel(string storeId, string cryptoCode, OpenLightningChannelRequest request,
+        public virtual async Task OpenLightningChannel(string storeId, string cryptoCode, OpenLightningChannelRequest request,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels", bodyPayload: request,
                     method: HttpMethod.Post), token);
-            return await HandleResponse<string>(response);
+            await HandleResponse(response);
         }
 
-        public async Task<string> GetLightningDepositAddress(string storeId, string cryptoCode,
+        public virtual async Task<string> GetLightningDepositAddress(string storeId, string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -56,7 +65,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<string>(response);
         }
 
-        public async Task PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
+        public virtual async Task PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -67,7 +76,18 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public async Task<LightningInvoiceData> GetLightningInvoice(string storeId, string cryptoCode,
+        public virtual async Task<LightningPaymentData> GetLightningPayment(string storeId, string cryptoCode,
+            string paymentHash, CancellationToken token = default)
+        {
+            if (paymentHash == null)
+                throw new ArgumentNullException(nameof(paymentHash));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments/{paymentHash}",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningPaymentData>(response);
+        }
+
+        public virtual async Task<LightningInvoiceData> GetLightningInvoice(string storeId, string cryptoCode,
             string invoiceId, CancellationToken token = default)
         {
             if (invoiceId == null)
@@ -78,7 +98,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<LightningInvoiceData>(response);
         }
 
-        public async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
+        public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
             CreateLightningInvoiceRequest request, CancellationToken token = default)
         {
             if (request == null)

BTCPayServer.Client/BTCPayServerClient.LightningNetworkPaymentMethods.cs

@@ -0,0 +1,59 @@
+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<IEnumerable<LightningNetworkPaymentMethodData>>
+            GetStoreLightningNetworkPaymentMethods(string storeId, bool? enabled = null,
+                CancellationToken token = default)
+        {
+            var query = new Dictionary<string, object>();
+            if (enabled != null)
+            {
+                query.Add(nameof(enabled), enabled);
+            }
+
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork",
+                        query), token);
+            return await HandleResponse<IEnumerable<LightningNetworkPaymentMethodData>>(response);
+        }
+
+        public virtual async Task<LightningNetworkPaymentMethodData> GetStoreLightningNetworkPaymentMethod(
+            string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork/{cryptoCode}"), token);
+            return await HandleResponse<LightningNetworkPaymentMethodData>(response);
+        }
+
+        public virtual async Task RemoveStoreLightningNetworkPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork/{cryptoCode}",
+                        method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<LightningNetworkPaymentMethodData> UpdateStoreLightningNetworkPaymentMethod(
+            string storeId,
+            string cryptoCode, UpdateLightningNetworkPaymentMethodRequest paymentMethod,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork/{cryptoCode}",
+                    bodyPayload: paymentMethod, method: HttpMethod.Put), token);
+            return await HandleResponse<LightningNetworkPaymentMethodData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Misc.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<PermissionMetadata[]> GetPermissionMetadata(CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest("misc/permissions"), token);
+            return await HandleResponse<PermissionMetadata[]>(response);
+        }
+        public virtual async Task<Language[]> GetAvailableLanguages(CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest("misc/lang"), token);
+            return await HandleResponse<Language[]>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Notifications.cs

@@ -0,0 +1,56 @@
+using System;
+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<IEnumerable<NotificationData>> GetNotifications(bool? seen = null, int? skip = null,
+            int? take = null, CancellationToken token = default)
+        {
+            Dictionary<string, object> queryPayload = new Dictionary<string, object>();
+
+            if (seen != null)
+                queryPayload.Add(nameof(seen), seen);
+            if (skip != null)
+                queryPayload.Add(nameof(skip), skip);
+            if (take != null)
+                queryPayload.Add(nameof(take), take);
+
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/users/me/notifications",
+                    queryPayload), token);
+
+            return await HandleResponse<IEnumerable<NotificationData>>(response);
+        }
+
+        public virtual async Task<NotificationData> GetNotification(string notificationId,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/users/me/notifications/{notificationId}"), token);
+            return await HandleResponse<NotificationData>(response);
+        }
+
+        public virtual async Task<NotificationData> UpdateNotification(string notificationId, bool? seen,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/users/me/notifications/{notificationId}",
+                    method: HttpMethod.Put, bodyPayload: new UpdateNotification() { Seen = seen }), token);
+            return await HandleResponse<NotificationData>(response);
+        }
+
+        public virtual async Task RemoveNotification(string notificationId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/users/me/notifications/{notificationId}",
+                    method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.OnChainPaymentMethods.cs

@@ -0,0 +1,94 @@
+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<IEnumerable<OnChainPaymentMethodData>> GetStoreOnChainPaymentMethods(string storeId,
+            bool? enabled = null,
+            CancellationToken token = default)
+        {
+            var query = new Dictionary<string, object>();
+            if (enabled != null)
+            {
+                query.Add(nameof(enabled), enabled);
+            }
+
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain",
+                        query), token);
+            return await HandleResponse<IEnumerable<OnChainPaymentMethodData>>(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodData> GetStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}"), token);
+            return await HandleResponse<OnChainPaymentMethodData>(response);
+        }
+
+        public virtual async Task RemoveStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}",
+                        method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodData> UpdateStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, UpdateOnChainPaymentMethodRequest paymentMethod,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}",
+                    bodyPayload: paymentMethod, method: HttpMethod.Put), token);
+            return await HandleResponse<OnChainPaymentMethodData>(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodPreviewResultData>
+            PreviewProposedStoreOnChainPaymentMethodAddresses(
+                string storeId, string cryptoCode, UpdateOnChainPaymentMethodRequest paymentMethod, int offset = 0,
+                int amount = 10,
+                CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/preview",
+                    bodyPayload: paymentMethod,
+                    queryPayload: new Dictionary<string, object>() { { "offset", offset }, { "amount", amount } },
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodPreviewResultData> PreviewStoreOnChainPaymentMethodAddresses(
+            string storeId, string cryptoCode, int offset = 0, int amount = 10,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/preview",
+                    queryPayload: new Dictionary<string, object>() { { "offset", offset }, { "amount", amount } },
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodDataWithSensitiveData> GenerateOnChainWallet(string storeId,
+            string cryptoCode, GenerateOnChainWalletRequest request,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/generate",
+                    bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<OnChainPaymentMethodDataWithSensitiveData>(response);
+        }
+
+    }
+}

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.cs

@@ -0,0 +1,139 @@
+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<OnChainWalletOverviewData> ShowOnChainWalletOverview(string storeId, string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet"), token);
+            return await HandleResponse<OnChainWalletOverviewData>(response);
+        }
+        public virtual async Task<OnChainWalletFeeRateData> GetOnChainFeeRate(string storeId, string cryptoCode, int? blockTarget = null,
+            CancellationToken token = default)
+        {
+            Dictionary<string, object> queryParams = new Dictionary<string, object>();
+            if (blockTarget != null)
+            {
+                queryParams.Add("blockTarget", blockTarget);
+            }
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/feeRate", queryParams), token);
+            return await HandleResponse<OnChainWalletFeeRateData>(response);
+        }
+
+        public virtual async Task<OnChainWalletAddressData> GetOnChainWalletReceiveAddress(string storeId, string cryptoCode, bool forceGenerate = false,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", new Dictionary<string, object>()
+                    {
+                        {"forceGenerate", forceGenerate}
+                    }), token);
+            return await HandleResponse<OnChainWalletAddressData>(response);
+        }
+
+        public virtual async Task UnReserveOnChainWalletReceiveAddress(string storeId, string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<IEnumerable<OnChainWalletTransactionData>> ShowOnChainWalletTransactions(
+            string storeId, string cryptoCode, TransactionStatus[] statusFilter = null, string labelFilter = null,
+            CancellationToken token = default)
+        {
+            var query = new Dictionary<string, object>();
+            if (statusFilter?.Any() is true)
+            {
+                query.Add(nameof(statusFilter), statusFilter);
+            }
+            if (labelFilter != null) {
+                query.Add(nameof(labelFilter), labelFilter);
+            }
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", query), token);
+            return await HandleResponse<IEnumerable<OnChainWalletTransactionData>>(response);
+        }
+
+        public virtual async Task<OnChainWalletTransactionData> GetOnChainWalletTransaction(
+            string storeId, string cryptoCode, string transactionId,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}"), token);
+            return await HandleResponse<OnChainWalletTransactionData>(response);
+        }
+
+        public virtual async Task<OnChainWalletTransactionData> PatchOnChainWalletTransaction(
+            string storeId, string cryptoCode, string transactionId,
+            PatchOnChainTransactionRequest request,
+            bool force = false, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}", queryPayload: new Dictionary<string, object>()
+                    {
+                        {"force", force}
+                    }, bodyPayload: request, HttpMethod.Patch), token);
+            return await HandleResponse<OnChainWalletTransactionData>(response);
+        }
+
+        public virtual async Task<IEnumerable<OnChainWalletUTXOData>> GetOnChainWalletUTXOs(string storeId,
+            string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/utxos"), token);
+            return await HandleResponse<IEnumerable<OnChainWalletUTXOData>>(response);
+        }
+
+        public virtual async Task<OnChainWalletTransactionData> CreateOnChainTransaction(string storeId,
+            string cryptoCode, CreateOnChainTransactionRequest request,
+            CancellationToken token = default)
+        {
+            if (!request.ProceedWithBroadcast)
+            {
+                throw new ArgumentOutOfRangeException(nameof(request.ProceedWithBroadcast),
+                    "Please use CreateOnChainTransactionButDoNotBroadcast when wanting to only create the transaction");
+            }
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", null, request, HttpMethod.Post), token);
+            return await HandleResponse<OnChainWalletTransactionData>(response);
+        }
+
+        public virtual async Task<Transaction> CreateOnChainTransactionButDoNotBroadcast(string storeId,
+            string cryptoCode, CreateOnChainTransactionRequest request, Network network,
+            CancellationToken token = default)
+        {
+            if (request.ProceedWithBroadcast)
+            {
+                throw new ArgumentOutOfRangeException(nameof(request.ProceedWithBroadcast),
+                    "Please use CreateOnChainTransaction when wanting to also broadcast the transaction");
+            }
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", null, request, HttpMethod.Post), token);
+            return Transaction.Parse(await HandleResponse<string>(response), network);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.PaymentRequests.cs

@@ -16,7 +16,7 @@ namespace BTCPayServer.Client
             var response =
                 await _httpClient.SendAsync(
                     CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests",
-                        new Dictionary<string, object>() {{nameof(includeArchived), includeArchived}}), token);
+                        new Dictionary<string, object>() { { nameof(includeArchived), includeArchived } }), token);
             return await HandleResponse<IEnumerable<PaymentRequestData>>(response);
         }
 

BTCPayServer.Client/BTCPayServerClient.PayoutProcessors.cs

@@ -0,0 +1,18 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/payout-processors"), token);
+            return await HandleResponse<IEnumerable<PayoutProcessorData>>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.PullPayments.cs

@@ -9,18 +9,18 @@ namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
+        public virtual async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", bodyPayload: request, method: HttpMethod.Post), cancellationToken);
             return await HandleResponse<PullPaymentData>(response);
         }
-        public async Task<PullPaymentData> GetPullPayment(string pullPaymentId, CancellationToken cancellationToken = default)
+        public virtual async Task<PullPaymentData> GetPullPayment(string pullPaymentId, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", method: HttpMethod.Get), cancellationToken);
             return await HandleResponse<PullPaymentData>(response);
         }
 
-        public async Task<PullPaymentData[]> GetPullPayments(string storeId, bool includeArchived = false, CancellationToken cancellationToken = default)
+        public virtual async Task<PullPaymentData[]> GetPullPayments(string storeId, bool includeArchived = false, CancellationToken cancellationToken = default)
         {
             Dictionary<string, object> query = new Dictionary<string, object>();
             query.Add("includeArchived", includeArchived);
@@ -28,34 +28,55 @@ namespace BTCPayServer.Client
             return await HandleResponse<PullPaymentData[]>(response);
         }
 
-        public async Task ArchivePullPayment(string storeId, string pullPaymentId, CancellationToken cancellationToken = default)
+        public virtual async Task ArchivePullPayment(string storeId, string pullPaymentId, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", method: HttpMethod.Delete), cancellationToken);
             await HandleResponse(response);
         }
 
-        public async Task<PayoutData[]> GetPayouts(string pullPaymentId, bool includeCancelled = false, CancellationToken cancellationToken = default)
+        public virtual async Task<PayoutData[]> GetPayouts(string pullPaymentId, bool includeCancelled = false, CancellationToken cancellationToken = default)
         {
             Dictionary<string, object> query = new Dictionary<string, object>();
             query.Add("includeCancelled", includeCancelled);
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", queryPayload: query, method: HttpMethod.Get), cancellationToken);
             return await HandleResponse<PayoutData[]>(response);
         }
-        public async Task<PayoutData> CreatePayout(string pullPaymentId, CreatePayoutRequest payoutRequest, CancellationToken cancellationToken = default)
+        public virtual async Task<PayoutData[]> GetStorePayouts(string storeId, bool includeCancelled = false, CancellationToken cancellationToken = default)
+        {
+            Dictionary<string, object> query = new Dictionary<string, object>();
+            query.Add("includeCancelled", includeCancelled);
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payouts", queryPayload: query, method: HttpMethod.Get), cancellationToken);
+            return await HandleResponse<PayoutData[]>(response);
+        }
+        public virtual async Task<PayoutData> CreatePayout(string pullPaymentId, CreatePayoutRequest payoutRequest, CancellationToken cancellationToken = default)
         {
             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> 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);
+            return await HandleResponse<PayoutData>(response);
         }
-
-        public async Task CancelPayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
+        public virtual async Task CancelPayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", method: HttpMethod.Delete), cancellationToken);
             await HandleResponse(response);
         }
-        public async Task<PayoutData> ApprovePayout(string storeId, string payoutId, ApprovePayoutRequest request, CancellationToken cancellationToken = default)
+        public virtual async Task<PayoutData> ApprovePayout(string storeId, string payoutId, ApprovePayoutRequest request, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", bodyPayload: request, method: HttpMethod.Post), cancellationToken);
             return await HandleResponse<PayoutData>(response);
         }
+
+        public async Task MarkPayoutPaid(string storeId, string payoutId,
+            CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest(
+                    $"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark-paid",
+                    method: HttpMethod.Post), cancellationToken);
+            await HandleResponse(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreEmail.cs

@@ -0,0 +1,37 @@
+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<EmailSettingsData> GetStoreEmailSettings(string storeId,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/email", method: HttpMethod.Get),
+                token);
+            return await HandleResponse<EmailSettingsData>(response);
+        }
+
+        public virtual async Task<EmailSettingsData> UpdateStoreEmailSettings(string storeId, EmailSettingsData request,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/email", bodyPayload: request, method: HttpMethod.Put),
+                token);
+            return await HandleResponse<EmailSettingsData>(response);
+        }
+
+        public virtual async Task SendEmail(string storeId, SendEmailRequest request,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/email/send", bodyPayload: request, method: HttpMethod.Post),
+                token);
+            await HandleResponse(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.StorePaymentMethods.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<Dictionary<string, GenericPaymentMethodData>> GetStorePaymentMethods(string storeId,
+            bool? enabled = null,
+            CancellationToken token = default)
+        {
+            var query = new Dictionary<string, object>();
+            if (enabled != null)
+            {
+                query.Add(nameof(enabled), enabled);
+            }
+
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods",
+                        query), token);
+            return await HandleResponse<Dictionary<string, GenericPaymentMethodData>>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.StorePayoutProcessors.cs

@@ -0,0 +1,48 @@
+#nullable enable
+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<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(string storeId, 
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors"), token);
+            return await HandleResponse<IEnumerable<PayoutProcessorData>>(response);
+        }
+        public virtual async Task RemovePayoutProcessor(string storeId, string processor, string paymentMethod, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/{processor}/{paymentMethod}", null, HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+        
+        public virtual async Task<IEnumerable<LightningAutomatedPayoutSettings>> GetStoreLightningAutomatedPayoutProcessors(string storeId, string? paymentMethod = null,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory{(paymentMethod is null? string.Empty: $"/{paymentMethod}")}"), token);
+            return await HandleResponse<IEnumerable<LightningAutomatedPayoutSettings>>(response);
+        }
+        public virtual async Task<LightningAutomatedPayoutSettings> UpdateStoreLightningAutomatedPayoutProcessors(string storeId, string paymentMethod,LightningAutomatedPayoutSettings request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory/{paymentMethod}",null, request, HttpMethod.Put ), token);
+            return await HandleResponse<LightningAutomatedPayoutSettings>(response);
+        }
+        public virtual async Task<OnChainAutomatedPayoutSettings> UpdateStoreOnChainAutomatedPayoutProcessors(string storeId, string paymentMethod,OnChainAutomatedPayoutSettings request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory/{paymentMethod}",null, request, HttpMethod.Put ), token);
+            return await HandleResponse<OnChainAutomatedPayoutSettings>(response);
+        }
+        
+        public virtual async Task<IEnumerable<OnChainAutomatedPayoutSettings>> GetStoreOnChainAutomatedPayoutProcessors(string storeId, string? paymentMethod = null,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory{(paymentMethod is null? string.Empty: $"/{paymentMethod}")}"), token);
+            return await HandleResponse<IEnumerable<OnChainAutomatedPayoutSettings>>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

@@ -0,0 +1,37 @@
+using System;
+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<IEnumerable<StoreUserData>> GetStoreUsers(string storeId,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/users"), token);
+            return await HandleResponse<IEnumerable<StoreUserData>>(response);
+        }
+
+        public virtual async Task RemoveStoreUser(string storeId, string userId, CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/users/{userId}", method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task AddStoreUser(string storeId, StoreUserData request,
+            CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/users", bodyPayload: request, method: HttpMethod.Post),
+                token);
+            await HandleResponse(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Users.cs

@@ -1,3 +1,4 @@
+#nullable enable
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -19,5 +20,35 @@ namespace BTCPayServer.Client
             var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/users", null, request, HttpMethod.Post), token);
             return await HandleResponse<ApplicationUserData>(response);
         }
+
+        public virtual async Task DeleteUser(string userId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}", null, HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<ApplicationUserData> GetUserByIdOrEmail(string idOrEmail, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}", null, HttpMethod.Get), token);
+            return await HandleResponse<ApplicationUserData>(response);
+        }
+
+        public virtual async Task LockUser(string idOrEmail, bool locked, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}/lock", null,
+                new LockUserRequest() {Locked = locked}, HttpMethod.Post), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<ApplicationUserData[]> GetUsers( CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/", null, HttpMethod.Get), token);
+            return await HandleResponse<ApplicationUserData[]>(response);
+        }
+
+        public virtual async Task DeleteCurrentUser(CancellationToken token = default)
+        {
+            await DeleteUser("me", token);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Webhooks.cs

@@ -1,60 +1,58 @@
-using System;
-using System.Collections.Generic;
 using System.Net.Http;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
-using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public async Task<StoreWebhookData> CreateWebhook(string storeId, Client.Models.CreateStoreWebhookRequest create, CancellationToken token = default)
+        public virtual async Task<StoreWebhookData> CreateWebhook(string storeId, Client.Models.CreateStoreWebhookRequest create, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks", bodyPayload: create, method: HttpMethod.Post), token);
             return await HandleResponse<StoreWebhookData>(response);
         }
-        public async Task<StoreWebhookData> GetWebhook(string storeId, string webhookId, CancellationToken token = default)
+        public virtual async Task<StoreWebhookData> GetWebhook(string storeId, string webhookId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}"), token);
             if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
                 return null;
             return await HandleResponse<StoreWebhookData>(response);
         }
-        public async Task<StoreWebhookData> UpdateWebhook(string storeId, string webhookId, Models.UpdateStoreWebhookRequest update, CancellationToken token = default)
+        public virtual async Task<StoreWebhookData> UpdateWebhook(string storeId, string webhookId, Models.UpdateStoreWebhookRequest update, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}", bodyPayload: update, method: HttpMethod.Put), token);
             return await HandleResponse<StoreWebhookData>(response);
         }
-        public async Task<bool> DeleteWebhook(string storeId, string webhookId, CancellationToken token = default)
+        public virtual async Task<bool> DeleteWebhook(string storeId, string webhookId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}", method: HttpMethod.Delete), token);
             return response.IsSuccessStatusCode;
         }
-        public async Task<StoreWebhookData[]> GetWebhooks(string storeId, CancellationToken token = default)
+        public virtual async Task<StoreWebhookData[]> GetWebhooks(string storeId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks"), token);
             return await HandleResponse<StoreWebhookData[]>(response);
         }
-        public async Task<WebhookDeliveryData[]> GetWebhookDeliveries(string storeId, string webhookId, CancellationToken token = default)
+        public virtual async Task<WebhookDeliveryData[]> GetWebhookDeliveries(string storeId, string webhookId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries"), token);
             return await HandleResponse<WebhookDeliveryData[]>(response);
         }
-        public async Task<WebhookDeliveryData> GetWebhookDelivery(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+        public virtual async Task<WebhookDeliveryData> GetWebhookDelivery(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}"), token);
+            if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
+                return null;
             return await HandleResponse<WebhookDeliveryData>(response);
         }
-        public async Task<string> RedeliverWebhook(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+        public virtual async Task<string> RedeliverWebhook(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/redeliver", null, HttpMethod.Post), token);
             return await HandleResponse<string>(response);
         }
 
-        public async Task<WebhookEvent> GetWebhookDeliveryRequest(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+        public virtual async Task<WebhookEvent> GetWebhookDeliveryRequest(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/request"), token);
             if (response.StatusCode == System.Net.HttpStatusCode.NotFound)

BTCPayServer.Client/BTCPayServerClient.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
@@ -17,7 +18,6 @@ namespace BTCPayServer.Client
         private readonly string _username;
         private readonly string _password;
         private readonly HttpClient _httpClient;
-
         public Uri Host => _btcpayHost;
 
         public string APIKey => _apiKey;
@@ -47,18 +47,25 @@ namespace BTCPayServer.Client
 
         protected async Task HandleResponse(HttpResponseMessage message)
         {
-            if (message.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
+            if (!message.IsSuccessStatusCode && message.Content?.Headers?.ContentType?.MediaType?.StartsWith("application/json", StringComparison.OrdinalIgnoreCase) is true)
             {
-                var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(await message.Content.ReadAsStringAsync());
-                ;
-                throw new GreenFieldValidationException(err);
+                if (message.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
+                {
+                    var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(await message.Content.ReadAsStringAsync());
+                    throw new GreenfieldValidationException(err);
+                }
+                if (message.StatusCode == System.Net.HttpStatusCode.Forbidden)
+                {
+                    var err = JsonConvert.DeserializeObject<Models.GreenfieldPermissionAPIError>(await message.Content.ReadAsStringAsync());
+                    throw new GreenfieldAPIException((int)message.StatusCode, err);
+                }
+                else
+                {
+                    var err = JsonConvert.DeserializeObject<Models.GreenfieldAPIError>(await message.Content.ReadAsStringAsync());
+                    if (err.Code != null)
+                        throw new GreenfieldAPIException((int)message.StatusCode, err);
+                }
             }
-            else if (message.StatusCode == System.Net.HttpStatusCode.BadRequest)
-            {
-                var err = JsonConvert.DeserializeObject<Models.GreenfieldAPIError>(await message.Content.ReadAsStringAsync());
-                throw new GreenFieldAPIException(err);
-            }
-
             message.EnsureSuccessStatusCode();
         }
 
@@ -69,6 +76,20 @@ namespace BTCPayServer.Client
             return JsonConvert.DeserializeObject<T>(str);
         }
 
+        public async Task<T> SendHttpRequest<T>(string path,
+            Dictionary<string, object> queryPayload = null,
+            HttpMethod method = null, CancellationToken cancellationToken = default)
+        {
+            using var resp = await _httpClient.SendAsync(CreateHttpRequest(path, queryPayload, method), cancellationToken);
+            return await HandleResponse<T>(resp);
+        }
+        public async Task<T> SendHttpRequest<T>(string path,
+        object bodyPayload = null,
+        HttpMethod method = null, CancellationToken cancellationToken = default)
+        {
+            using var resp = await _httpClient.SendAsync(CreateHttpRequest(path: path, bodyPayload: bodyPayload, method: method), cancellationToken);
+            return await HandleResponse<T>(resp);
+        }
         protected virtual HttpRequestMessage CreateHttpRequest(string path,
             Dictionary<string, object> queryPayload = null,
             HttpMethod method = null)

BTCPayServer.Client/GreenFieldAPIException.cs

@@ -2,14 +2,16 @@ using System;
 
 namespace BTCPayServer.Client
 {
-    public class GreenFieldAPIException : Exception
+    public class GreenfieldAPIException : Exception
     {
-        public GreenFieldAPIException(Models.GreenfieldAPIError error) : base(error.Message)
+        public GreenfieldAPIException(int httpCode, Models.GreenfieldAPIError error) : base(error.Message)
         {
             if (error == null)
                 throw new ArgumentNullException(nameof(error));
+            HttpCode = httpCode;
             APIError = error;
         }
         public Models.GreenfieldAPIError APIError { get; }
+        public int HttpCode { get; set; }
     }
 }