update hook names

Two changes which fix #4807:

- Once permissions are granted we start scanning immediately, no need to ask for permissions or have the user click the button again
- We don't abort the scan, which gets rid of the cases in which the OS took over after the scan, because the user left the card on the device

Also adds feedback for the NFC states scanning and submitting.

.circleci/config.yml

@@ -2,7 +2,7 @@ version: 2
 jobs:
   fast_tests:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
       - checkout
       - run:
@@ -10,7 +10,7 @@ jobs:
             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,7 +18,7 @@ jobs:
             cd .circleci && ./run-tests.sh "Selenium=Selenium"
   integration_tests:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
       - checkout
       - run:
@@ -26,72 +26,69 @@ jobs:
             cd .circleci && ./run-tests.sh "Integration=Integration"
   trigger_docs_build:
     machine:
-        enabled: true
-        image: circleci/classic:201808-01
+      image: ubuntu-2004:202111-02
     steps:
       - run:
           command: |
-            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"}'
+            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
+            GIT_COMMIT=$(git rev-parse HEAD)
             #
-            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f amd64.Dockerfile .
-            sudo docker build --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 -f amd64.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f amd64.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 -f amd64.Dockerfile .
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-amd64
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64
 
   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
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            GIT_COMMIT=$(git rev-parse HEAD)
             #
-            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f arm32v7.Dockerfile .
-            sudo docker build --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 -f arm32v7.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f arm32v7.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 -f arm32v7.Dockerfile .
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7
 
   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
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            GIT_COMMIT=$(git rev-parse HEAD)
             #
-            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 -f arm64v8.Dockerfile .
-            sudo docker build --build-arg CONFIGURATION_NAME=Altcoins-Release --pull -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8 -f arm64v8.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 -f arm64v8.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --build-arg CONFIGURATION_NAME=Altcoins-Release --pull -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8 -f arm64v8.Dockerfile .
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm64v8
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8
 
   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
@@ -100,8 +97,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

.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

@@ -11,10 +11,14 @@ insert_final_newline = true
 indent_style = space
 indent_size = 4
 charset = utf-8
+space_before_self_closing = true
 
-[launchSettings.json]
+[*.json]
 indent_size = 2
 
+[swagger*.json]
+indent_size = 4
+
 # C# files
 [*.cs]
 # New line preferences
@@ -67,7 +71,7 @@ dotnet_naming_symbols.private_internal_fields.applicable_kinds = field
 dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal
 
 dotnet_naming_style.camel_case_underscore_style.required_prefix = _
-dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case 
+dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case
 
 # Code style defaults
 dotnet_sort_system_directives_first = true

.github/ISSUE_TEMPLATE/bug-report.md

@@ -1,63 +0,0 @@
----
-name: "\U0001F41B Bug report"
-about: Report a bug or a technical issue
-
----
-
-<!--
-Thank you for reporting a technical issue.
-
-This issue tracker is only for bug reports and problems. 
-
-For general questions please read our documentation docs.btcpayserver.org. You can ask technical questions in discussions https://github.com/btcpayserver/btcpayserver/discussions and general support on our community chat chat.btcpayserver.org
-
-Please fill in as much of the template below as you're able. 
--->
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce the bug**
-Steps to reproduce the reported bug:
-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,11 +1,17 @@
-blank_issues_enabled: false
-contact_links: 
-  - name: 🚀 Discussions  
-    url: https://github.com/btcpayserver/btcpayserver/discussions
-    about: Technical discussions, questions and feature requests    
+blank_issues_enabled: true
+contact_links:
+  - name: 💡 Request a feature
+    url: https://github.com/btcpayserver/btcpayserver/discussions/categories/ideas-feature-requests
+    about: Submit a feature request or vote on ideas posted by others. Features with most upvotes become roadmap candidates
+  - name: 🧑‍💻 Ask a technical question
+    url: https://github.com/btcpayserver/btcpayserver/discussions/new?category=technical-support
+    about: If you're experiencing a technical problem post it to our community support forum
+  - name: 🔌 Report a problem with a plugin
+    url: https://github.com/btcpayserver/btcpayserver/discussions/new?category=plugins-integrations
+    about: Experiencing a problem with a third-party plugin? Post it here and we will tag their developers to assist
   - name: 📝 Official Documentation
     url: https://docs.btcpayserver.org
-    about: Check our documentation for answers to common questions 
-  - name: 💬 Community Support Chat  
+    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

.gitignore

@@ -288,10 +288,6 @@ __pycache__/
 *.xsd.cs
 /BTCPayServer/Build/dockerfiles
 
-# Bundling JS/CSS
-BTCPayServer/wwwroot/bundles/*
-!BTCPayServer/wwwroot/bundles/.gitignore
-
 .vscode/*
 !.vscode/launch.json
 !.vscode/tasks.json
@@ -300,3 +296,6 @@ BTCPayServer/testpwd
 .DS_Store
 Packed Plugins
 Plugins/packed
+
+BTCPayServer/wwwroot/swagger/v1/openapi.json
+BTCPayServer/appsettings.dev.json

.run/Pack Test Extension.run.xml

@@ -14,8 +14,8 @@
     <option name="PROJECT_KIND" value="DotNetCore" />
     <option name="PROJECT_TFM" value=".NETCoreApp,Version=v3.1" />
     <method v="2">
-      <option name="Build" default="false" projectName="BTCPayServer.Plugins.Test" projectPath="C:\Git\btcpayserver\BTCPayServer.Plugins.Test\BTCPayServer.Plugins.Test.csproj" />
+      <option name="Build" default="false" projectName="BTCPayServer.Plugins.Test" projectPath="C:\Git\btcpayserver\Plugins\BTCPayServer.Plugins.Test\BTCPayServer.Plugins.Test.csproj" />
       <option name="Build" />
     </method>
   </configuration>
-</component>
+</component>

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -31,10 +31,11 @@
     <None Include="icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.1" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.1" />
-    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="6.0.0" />
+    <PackageReference Include="HtmlSanitizer" Version="5.0.372" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.9" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.9" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.7" />
+    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="6.0.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\BTCPayServer.Client\BTCPayServer.Client.csproj" />

BTCPayServer.Abstractions/CamelCaseSerializerSettings.cs

@@ -0,0 +1,18 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Abstractions
+{
+    public class CamelCaseSerializerSettings
+    {
+        static CamelCaseSerializerSettings()
+        {
+            Settings = new JsonSerializerSettings()
+            {
+                ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver()
+            };
+            Serializer = JsonSerializer.Create(Settings);
+        }
+        public static readonly JsonSerializerSettings Settings;
+        public static readonly JsonSerializer Serializer;
+    }
+}

BTCPayServer.Abstractions/Configuration/DataDirectories.cs

@@ -1,3 +1,5 @@
+using System.IO;
+
 namespace BTCPayServer.Configuration
 {
     public class DataDirectories
@@ -6,7 +8,13 @@ namespace BTCPayServer.Configuration
         public string PluginDir { get; set; }
         public string TempStorageDir { get; set; }
         public string StorageDir { get; set; }
+        public string TempDir { get; set; }
+
+        public string ToDatadirFullPath(string path)
+        {
+            if (Path.IsPathRooted(path))
+                return path;
+            return Path.Combine(DataDir, path);
+        }
     }
-
-
 }

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

@@ -25,7 +25,7 @@ namespace BTCPayServer.Abstractions.Contracts
         class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
         {
 #pragma warning disable EF1001 // Internal EF Core API usage.
-            public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies, Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal.INpgsqlOptions opts) : base(dependencies, opts)
+            public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies, Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal.INpgsqlSingletonOptions opts) : base(dependencies, opts)
 #pragma warning restore EF1001 // Internal EF Core API usage.
             {
             }

BTCPayServer.Abstractions/Contracts/IBTCPayServerClientFactory.cs

@@ -1,10 +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/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

@@ -19,6 +19,8 @@ namespace BTCPayServer.Abstractions.Contracts
     public class NotificationViewModel
     {
         public string Id { get; set; }
+        public string Identifier { get; set; }
+        public string Type { get; set; }
         public DateTimeOffset Created { get; set; }
         public string Body { get; set; }
         public string ActionLink { get; set; }

BTCPayServer.Abstractions/Contracts/IScopeProvider.cs

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

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/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,12 @@
+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)
+    {
+    }
+
+    public AssetBalancesUnavailableException(string errorMsg) : base(500, "asset-balances-unavailable", $"Cannot fetch the asset balances: {errorMsg}")
+    {
+    }
+}

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,18 @@
+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,8 @@
+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,8 @@
+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/SimulateWithdrawalResult.cs

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

BTCPayServer.Abstractions/Custodians/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,31 @@
+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,20 @@
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Custodians.Client;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+/// <summary>
+/// Interface for custodians that can move funds to the store wallet.
+/// </summary>
+public interface ICanWithdraw
+{
+    public Task<WithdrawResult> WithdrawToStoreWalletAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken);
+
+    public Task<SimulateWithdrawalResult> SimulateWithdrawalAsync(string paymentMethod, decimal qty, JObject config, CancellationToken cancellationToken);
+
+    public Task<WithdrawResult> GetWithdrawalInfoAsync(string paymentMethod, string withdrawalId, JObject config, CancellationToken cancellationToken);
+
+    public string[] GetWithdrawablePaymentMethods();
+}

BTCPayServer.Abstractions/Custodians/ICustodian.cs

@@ -0,0 +1,25 @@
+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(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,47 @@
+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 UserNotFound(this ControllerBase ctrl)
+    {
+        return ctrl.CreateAPIError(404, "user-not-found", "The user was not found");
+    }
+    public static IActionResult CreateValidationError(this ControllerBase controller, ModelStateDictionary modelState)
+    {
+        return controller.UnprocessableEntity(modelState.ToGreenfieldValidationError());
+    }
+
+    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,43 @@
+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

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using Microsoft.AspNetCore.Html;
 using Microsoft.AspNetCore.Mvc.ViewFeatures;
 
@@ -10,6 +12,13 @@ namespace BTCPayServer.Abstractions.Extensions
         private const string ACTIVE_CATEGORY_KEY = "ActiveCategory";
         private const string ACTIVE_PAGE_KEY = "ActivePage";
         private const string ACTIVE_ID_KEY = "ActiveId";
+        private const string ActivePageClass = "active";
+
+        public enum DateDisplayFormat
+        {
+            Localized,
+            Relative
+        }
 
         public static void SetActivePage<T>(this ViewDataDictionary viewData, T activePage, string title = null, string activeId = null)
             where T : IConvertible
@@ -41,7 +50,7 @@ namespace BTCPayServer.Abstractions.Extensions
         {
             return IsActiveCategory(viewData, category.ToString(), id);
         }
-        
+
         public static string IsActiveCategory(this ViewDataDictionary viewData, string category, object id = null)
         {
             if (!viewData.ContainsKey(ACTIVE_CATEGORY_KEY))
@@ -52,7 +61,7 @@ namespace BTCPayServer.Abstractions.Extensions
             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;
+            return categoryMatch && idMatch ? ActivePageClass : null;
         }
 
         public static string IsActivePage<T>(this ViewDataDictionary viewData, T page, object id = null)
@@ -60,7 +69,15 @@ namespace BTCPayServer.Abstractions.Extensions
         {
             return IsActivePage(viewData, page.ToString(), page.GetType().ToString(), id);
         }
-        
+
+        public static string IsActivePage<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null)
+            where T : IConvertible
+        {
+            return pages.Any(page => IsActivePage(viewData, page.ToString(), page.GetType().ToString(), id) == ActivePageClass)
+                ? ActivePageClass
+                : null;
+        }
+
         public static string IsActivePage(this ViewDataDictionary viewData, string page, string category, object id = null)
         {
             if (!viewData.ContainsKey(ACTIVE_PAGE_KEY))
@@ -72,29 +89,32 @@ namespace BTCPayServer.Abstractions.Extensions
             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;
+            return categoryAndPageMatch && idMatch ? ActivePageClass : null;
         }
 
-        public static HtmlString ToBrowserDate(this DateTimeOffset date)
+        public static HtmlString ToBrowserDate(this DateTimeOffset date, DateDisplayFormat format = DateDisplayFormat.Localized)
         {
-            var displayDate = date.ToString("o", CultureInfo.InvariantCulture);
-            return new HtmlString($"<span class='localizeDate'>{displayDate}</span>");
+            var relative = date.ToTimeAgo();
+            var initial = format.ToString().ToLower();
+            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
+            var displayDate = format == DateDisplayFormat.Relative ? relative : date.ToString("g", CultureInfo.InvariantCulture);
+            return new HtmlString($"<time datetime=\"{dateTime}\" data-relative=\"{relative}\" data-initial=\"{initial}\">{displayDate}</time>");
         }
 
-        public static HtmlString ToBrowserDate(this DateTime date)
+        public static HtmlString ToBrowserDate(this DateTime date, DateDisplayFormat format = DateDisplayFormat.Localized)
         {
-            var displayDate = date.ToString("o", CultureInfo.InvariantCulture);
-            return new HtmlString($"<span class='localizeDate'>{displayDate}</span>");
+            var relative = date.ToTimeAgo();
+            var initial = format.ToString().ToLower();
+            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
+            var displayDate = format == DateDisplayFormat.Relative ? relative : date.ToString("g", CultureInfo.InvariantCulture);
+            return new HtmlString($"<time datetime=\"{dateTime}\" data-relative=\"{relative}\" data-initial=\"{initial}\">{displayDate}</time>");
         }
 
-        public static string ToTimeAgo(this DateTimeOffset date)
-        {
-            var diff = DateTimeOffset.UtcNow - date;
-            var formatted = diff.Seconds > 0
-                ? $"{diff.TimeString()} ago"
-                : $"in {diff.Negate().TimeString()}";
-            return formatted;
-        }
+        public static string ToTimeAgo(this DateTimeOffset date) => (DateTimeOffset.UtcNow - date).ToTimeAgo();
+
+        public static string ToTimeAgo(this DateTime date) => (DateTimeOffset.UtcNow - date).ToTimeAgo();
+
+        public static string ToTimeAgo(this TimeSpan diff) => diff.TotalSeconds > 0 ? $"{diff.TimeString()} ago" : $"in {diff.Negate().TimeString()}";
 
         public static string TimeString(this TimeSpan timeSpan)
         {
@@ -106,16 +126,14 @@ namespace BTCPayServer.Abstractions.Extensions
             {
                 return $"{(int)timeSpan.TotalMinutes} minute{Plural((int)timeSpan.TotalMinutes)}";
             }
-            if (timeSpan.Days < 1)
-            {
-                return $"{(int)timeSpan.TotalHours} hour{Plural((int)timeSpan.TotalHours)}";
-            }
-            return $"{(int)timeSpan.TotalDays} day{Plural((int)timeSpan.TotalDays)}";
+            return timeSpan.Days < 1
+                ? $"{(int)timeSpan.TotalHours} hour{Plural((int)timeSpan.TotalHours)}"
+                : $"{(int)timeSpan.TotalDays} day{Plural((int)timeSpan.TotalDays)}";
         }
 
-        private static string Plural(int totalDays)
+        private static string Plural(int value)
         {
-            return totalDays > 1 ? "s" : string.Empty;
+            return value == 1 ? string.Empty : "s";
         }
     }
 }

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,64 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public class Field
+{
+    public static Field Create(string label, string name, string value, bool required, string helpText, string type = "text")
+    {
+        return new Field
+        {
+            Label = label,
+            Name = name,
+            Value = value,
+            OriginalValue = value,
+            Required = required,
+            HelpText = helpText,
+            Type = type
+        };
+    }
+    // The name of the HTML5 node. Should be used as the key for the posted data.
+    public string Name;
+
+    public bool Constant;
+
+    // HTML5 compatible type string like "text", "textarea", "email", "password", etc.
+    public string Type;
+
+    public static Field CreateFieldset()
+    {
+        return new Field { Type = "fieldset" };
+    }
+
+    // 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;
+
+    public bool Required;
+
+    // The translated label of the field.
+    public string Label;
+
+    // The original value is the value that is currently saved in the backend. A "reset" button can be used to revert back to this. Should only be set from the constructor.
+    public string OriginalValue;
+
+    // A useful note shown below the field or via a tooltip / info icon. Should be translated for the user.
+    public string HelpText;
+
+    [JsonExtensionData] public IDictionary<string, JToken> AdditionalData { get; set; }
+    public List<Field> Fields { get; set; } = new ();
+
+    // The field is considered "valid" if there are no validation errors
+    public List<string> ValidationErrors = new ();
+
+    public virtual bool IsValid()
+    {
+        return ValidationErrors.Count == 0 && Fields.All(field => field.IsValid());
+    }
+}

BTCPayServer.Abstractions/Form/Form.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Primitives;
+using Newtonsoft.Json.Linq;
+using Npgsql.Internal.TypeHandlers.GeometricHandlers;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public class Form
+{
+#nullable enable
+    public static Form Parse(string str)
+    {
+        ArgumentNullException.ThrowIfNull(str);
+        return JObject.Parse(str).ToObject<Form>(CamelCaseSerializerSettings.Serializer) ?? throw new InvalidOperationException("Impossible to deserialize Form");
+    }
+    public override string ToString()
+    {
+        return JObject.FromObject(this, CamelCaseSerializerSettings.Serializer).ToString(Newtonsoft.Json.Formatting.Indented);
+    }
+#nullable restore
+
+    // 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<Field> Fields { get; set; } = new();
+
+    // Are all the fields valid in the form?
+    public bool IsValid()
+    {
+        return Fields.Select(f => f.IsValid()).All(o => o);
+    }
+
+    public Field GetFieldByFullName(string fullName)
+    {
+        foreach (var f in GetAllFields())
+        {
+            if (f.FullName == fullName)
+                return f.Field;
+        }
+        return null;
+    }
+
+    public IEnumerable<(string FullName, List<string> Path, Field Field)> GetAllFields()
+    {
+        HashSet<string> nameReturned = new();
+        foreach (var f in GetAllFieldsCore(new List<string>(), Fields))
+        {
+            var fullName = string.Join('_', f.Path.Where(s => !string.IsNullOrEmpty(s)));
+            if (!nameReturned.Add(fullName))
+                continue;
+            yield return (fullName, f.Path, f.Field);
+        }
+    }
+
+    public bool ValidateFieldNames(out List<string> errors)
+    {
+        errors = new List<string>();
+        HashSet<string> nameReturned = new();
+        foreach (var f in GetAllFieldsCore(new List<string>(), Fields))
+        {
+            var fullName = string.Join('_', f.Path.Where(s => !string.IsNullOrEmpty(s)));
+            if (!nameReturned.Add(fullName))
+            {
+                errors.Add($"Form contains duplicate field names '{fullName}'");
+                continue;
+            }
+        }
+        return errors.Count == 0;
+    }
+
+    IEnumerable<(List<string> Path, Field Field)> GetAllFieldsCore(List<string> path, List<Field> fields)
+    {
+        foreach (var field in fields)
+        {
+            List<string> thisPath = new(path.Count + 1);
+            thisPath.AddRange(path);
+            if (!string.IsNullOrEmpty(field.Name))
+            {
+                thisPath.Add(field.Name);
+                yield return (thisPath, field);
+            }
+
+            foreach (var child in field.Fields)
+            {
+                if (field.Constant)
+                    child.Constant = true;
+                foreach (var descendant in GetAllFieldsCore(thisPath, field.Fields))
+                {
+                    yield return descendant;
+                }
+            }
+        }
+    }
+
+    public void ApplyValuesFromForm(IEnumerable<KeyValuePair<string, StringValues>> form)
+    {
+        var values = form.GroupBy(f => f.Key, f => f.Value).ToDictionary(g => g.Key, g => g.First());
+        foreach (var f in GetAllFields())
+        {
+            if (f.Field.Constant || !values.TryGetValue(f.FullName, out var val))
+                continue;
+
+            f.Field.Value = val;
+        }
+    }
+
+    public void SetValues(JObject values)
+    {
+        var fields = GetAllFields().ToDictionary(k => k.FullName, k => k.Field);
+        SetValues(fields, new List<string>(), values);
+    }
+
+    private void SetValues(Dictionary<string, Field> fields, List<string> path, JObject values)
+    {
+        foreach (var prop in values.Properties())
+        {
+            List<string> propPath = new List<string>(path.Count + 1);
+            propPath.AddRange(path);
+            propPath.Add(prop.Name);
+            if (prop.Value.Type == JTokenType.Object)
+            {
+                SetValues(fields, propPath, (JObject)prop.Value);
+            }
+            else if (prop.Value.Type == JTokenType.String)
+            {
+                var fullName = string.Join('_', propPath.Where(s => !string.IsNullOrEmpty(s)));
+                if (fields.TryGetValue(fullName, out var f) && !f.Constant)
+                    f.Value = prop.Value.Value<string>();
+            }
+        }
+    }
+
+    public JObject GetValues()
+    {
+        var r = new JObject();
+        foreach (var f in GetAllFields())
+        {
+            var node = r;
+            for (int i = 0; i < f.Path.Count - 1; i++)
+            {
+                var p = f.Path[i];
+                var child = node[p] as JObject;
+                if (child is null)
+                {
+                    child = new JObject();
+                    node[p] = child;
+                }
+                node = child;
+            }
+            node[f.Field.Name] = f.Field.Value;
+        }
+        return r;
+    }
+}

BTCPayServer.Abstractions/Models/BaseBTCPayServerPlugin.cs

@@ -8,18 +8,52 @@ namespace BTCPayServer.Abstractions.Models
 {
     public abstract class BaseBTCPayServerPlugin : IBTCPayServerPlugin
     {
-        public abstract string Identifier { get; }
-        public abstract string Name { get; }
+        public virtual string Identifier
+        {
+            get
+            {
+                return GetType().GetTypeInfo().Assembly.GetName().Name;
+            }
+        }
+        public virtual string Name
+        {
+            get
+            {
+                return GetType().GetTypeInfo().Assembly
+                        .GetCustomAttribute<AssemblyProductAttribute>()?
+                        .Product ?? "???";
+            }
+        }
 
         public virtual Version Version
         {
             get
             {
-                return Assembly.GetAssembly(GetType())?.GetName().Version ?? new Version(1, 0, 0, 0);
+                return GetVersion(GetType().GetTypeInfo().Assembly
+                        .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
+                        .InformationalVersion) ??
+                        Assembly.GetAssembly(GetType())?.GetName()?.Version ??
+                        new Version(1, 0, 0, 0);
             }
         }
 
-        public abstract string Description { get; }
+        private static Version GetVersion(string informationalVersion)
+        {
+            if (informationalVersion is null)
+                return null;
+            Version.TryParse(informationalVersion, out var r);
+            return r;
+        }
+
+        public virtual string Description
+        {
+            get
+            {
+                return GetType().GetTypeInfo().Assembly
+                        .GetCustomAttribute<AssemblyDescriptionAttribute>()?
+                        .Description ?? string.Empty;
+            }
+        }
         public bool SystemPlugin { get; set; }
         public virtual IBTCPayServerPlugin.PluginDependency[] Dependencies { get; } = Array.Empty<IBTCPayServerPlugin.PluginDependency>();
 

BTCPayServer.Abstractions/Models/ConfirmModel.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace BTCPayServer.Models
+namespace BTCPayServer.Abstractions.Models
 {
     public class ConfirmModel
     {

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

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

BTCPayServer.Abstractions/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/TagHelpers/CSPA.cs

@@ -1,7 +1,8 @@
 using System;
 using BTCPayServer.Security;
 using Microsoft.AspNetCore.Razor.TagHelpers;
-namespace BTCPayServer.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
 
 /// <summary>
 /// Add sha256- to allow inline event handlers in a:href=javascript:

BTCPayServer.Abstractions/TagHelpers/CSPEventTagHelper.cs

@@ -2,8 +2,8 @@ using System.Collections.Generic;
 using System.Linq;
 using BTCPayServer.Security;
 using Microsoft.AspNetCore.Razor.TagHelpers;
-namespace BTCPayServer.TagHelpers;
 
+namespace BTCPayServer.Abstractions.TagHelpers;
 
 /// <summary>
 /// Add 'unsafe-hashes' and sha256- to allow inline event handlers in CSP

BTCPayServer.Abstractions/TagHelpers/CSPInlineScriptTagHelper.cs

@@ -1,8 +1,8 @@
 using BTCPayServer.Security;
 using Microsoft.AspNetCore.Razor.TagHelpers;
 using NBitcoin;
-namespace BTCPayServer.TagHelpers;
 
+namespace BTCPayServer.Abstractions.TagHelpers;
 
 /// <summary>
 /// Add a nonce-* so the inline-script can pass CSP rule when they are rendered server-side

BTCPayServer.Abstractions/TagHelpers/CSPTemplate.cs

@@ -1,7 +1,8 @@
 using System.Threading.Tasks;
 using BTCPayServer.Security;
 using Microsoft.AspNetCore.Razor.TagHelpers;
-namespace BTCPayServer.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
 
 /// <summary>
 /// Add sha256- to allow inline event handlers in CSP

BTCPayServer.Abstractions/TagHelpers/PermissionTagHelper.cs

@@ -1,11 +1,10 @@
-#nullable enable
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Razor.TagHelpers;
 using Microsoft.Extensions.Logging;
-namespace BTCPayServer.TagHelpers;
 
+namespace BTCPayServer.Abstractions.TagHelpers;
 
 [HtmlTargetElement(Attributes = nameof(Permission))]
 public class PermissionTagHelper : TagHelper

BTCPayServer.Abstractions/TagHelpers/SVGUse.cs

@@ -1,15 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
 using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Razor.TagHelpers;
 using Microsoft.AspNetCore.Mvc.Rendering;
 using Microsoft.AspNetCore.Mvc.Routing;
 using Microsoft.AspNetCore.Mvc.ViewFeatures;
 using Microsoft.AspNetCore.Razor.TagHelpers;
 
-namespace BTCPayServer.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
+public class SVGUse : UrlResolutionTagHelper2
 {
     private readonly IFileVersionProvider _fileVersionProvider;
 
@@ -17,10 +23,20 @@ public class SVGUse : UrlResolutionTagHelper
     {
         _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);
+        var symbolIndex = attr!.IndexOf("#", StringComparison.InvariantCulture);
+        var start = attr.IndexOf("~", StringComparison.InvariantCulture) + 1; 
+        var length = (symbolIndex != -1 ? symbolIndex : attr.Length) - start;
+        var filePath = attr.Substring(start, length);
+        if (!string.IsNullOrEmpty(filePath))
+        {
+            var versioned = _fileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, filePath);
+            attr = attr.Replace(filePath, versioned);
+        }
         output.Attributes.SetAttribute("href", attr);
+        base.Process(context, output);
     }
 }

BTCPayServer.Abstractions/TagHelpers/SrvModel.cs

@@ -1,8 +1,9 @@
+using BTCPayServer.Abstractions.Services;
 using BTCPayServer.Security;
-using BTCPayServer.Services;
 using Microsoft.AspNetCore.Razor.TagHelpers;
 using NBitcoin;
-namespace BTCPayServer.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
 
 [HtmlTargetElement("srv-model")]
 public class SrvModel : TagHelper

BTCPayServer.Abstractions/TagHelpers/UrlResolutionTagHelper2.cs

@@ -0,0 +1,314 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Razor.TagHelpers;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.AspNetCore.Mvc.Routing;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+
+namespace BTCPayServer.Abstractions.TagHelpers
+{
+    // A copy of https://github.com/dotnet/aspnetcore/blob/39f0e0b8f40b4754418f81aef0de58a9204a1fe5/src/Mvc/Mvc.Razor/src/TagHelpers/UrlResolutionTagHelper.cs
+    // slightly modified to also work on use tag.
+    public class UrlResolutionTagHelper2 : TagHelper
+    {
+        // Valid whitespace characters defined by the HTML5 spec.
+        private static readonly char[] ValidAttributeWhitespaceChars =
+            new[] { '\t', '\n', '\u000C', '\r', ' ' };
+        private static readonly Dictionary<string, string[]> ElementAttributeLookups =
+            new(StringComparer.OrdinalIgnoreCase)
+            {
+                { "use", new[] { "href" } },
+                { "a", new[] { "href" } },
+                { "applet", new[] { "archive" } },
+                { "area", new[] { "href" } },
+                { "audio", new[] { "src" } },
+                { "base", new[] { "href" } },
+                { "blockquote", new[] { "cite" } },
+                { "button", new[] { "formaction" } },
+                { "del", new[] { "cite" } },
+                { "embed", new[] { "src" } },
+                { "form", new[] { "action" } },
+                { "html", new[] { "manifest" } },
+                { "iframe", new[] { "src" } },
+                { "img", new[] { "src", "srcset" } },
+                { "input", new[] { "src", "formaction" } },
+                { "ins", new[] { "cite" } },
+                { "link", new[] { "href" } },
+                { "menuitem", new[] { "icon" } },
+                { "object", new[] { "archive", "data" } },
+                { "q", new[] { "cite" } },
+                { "script", new[] { "src" } },
+                { "source", new[] { "src", "srcset" } },
+                { "track", new[] { "src" } },
+                { "video", new[] { "poster", "src" } },
+            };
+
+        /// <summary>
+        /// Creates a new <see cref="UrlResolutionTagHelper"/>.
+        /// </summary>
+        /// <param name="urlHelperFactory">The <see cref="IUrlHelperFactory"/>.</param>
+        /// <param name="htmlEncoder">The <see cref="HtmlEncoder"/>.</param>
+        public UrlResolutionTagHelper2(IUrlHelperFactory urlHelperFactory, HtmlEncoder htmlEncoder)
+        {
+            UrlHelperFactory = urlHelperFactory;
+            HtmlEncoder = htmlEncoder;
+        }
+
+        /// <inheritdoc />
+        public override int Order => -1000 - 999;
+
+        /// <summary>
+        /// The <see cref="IUrlHelperFactory"/>.
+        /// </summary>
+        protected IUrlHelperFactory UrlHelperFactory { get; }
+
+        /// <summary>
+        /// The <see cref="HtmlEncoder"/>.
+        /// </summary>
+        protected HtmlEncoder HtmlEncoder { get; }
+
+        /// <summary>
+        /// The <see cref="ViewContext"/>.
+        /// </summary>
+        [HtmlAttributeNotBound]
+        [ViewContext]
+        public ViewContext ViewContext { get; set; } = default!;
+
+        /// <inheritdoc />
+        public override void Process(TagHelperContext context, TagHelperOutput output)
+        {
+            ArgumentNullException.ThrowIfNull(context);
+            ArgumentNullException.ThrowIfNull(output);
+
+            if (output.TagName == null)
+            {
+                return;
+            }
+
+            if (ElementAttributeLookups.TryGetValue(output.TagName, out var attributeNames))
+            {
+                for (var i = 0; i < attributeNames.Length; i++)
+                {
+                    ProcessUrlAttribute(attributeNames[i], output);
+                }
+            }
+
+            // itemid can be present on any HTML element.
+            ProcessUrlAttribute("itemid", output);
+        }
+
+        /// <summary>
+        /// Resolves and updates URL values starting with '~/' (relative to the application's 'webroot' setting) for
+        /// <paramref name="output"/>'s <see cref="TagHelperOutput.Attributes"/> whose
+        /// <see cref="TagHelperAttribute.Name"/> is <paramref name="attributeName"/>.
+        /// </summary>
+        /// <param name="attributeName">The attribute name used to lookup values to resolve.</param>
+        /// <param name="output">The <see cref="TagHelperOutput"/>.</param>
+        protected void ProcessUrlAttribute(string attributeName, TagHelperOutput output)
+        {
+            ArgumentNullException.ThrowIfNull(attributeName);
+            ArgumentNullException.ThrowIfNull(output);
+
+            var attributes = output.Attributes;
+            // Read interface .Count once rather than per iteration
+            var attributesCount = attributes.Count;
+            for (var i = 0; i < attributesCount; i++)
+            {
+                var attribute = attributes[i];
+                if (!string.Equals(attribute.Name, attributeName, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                if (attribute.Value is string stringValue)
+                {
+                    if (TryResolveUrl(stringValue, resolvedUrl: out string? resolvedUrl))
+                    {
+                        attributes[i] = new TagHelperAttribute(
+                            attribute.Name,
+                            resolvedUrl,
+                            attribute.ValueStyle);
+                    }
+                }
+                else
+                {
+                    if (attribute.Value is IHtmlContent htmlContent)
+                    {
+                        var htmlString = htmlContent as HtmlString;
+                        if (htmlString != null)
+                        {
+                            // No need for a StringWriter in this case.
+                            stringValue = htmlString.ToString();
+                        }
+                        else
+                        {
+                            using var writer = new StringWriter();
+                            htmlContent.WriteTo(writer, HtmlEncoder);
+                            stringValue = writer.ToString();
+                        }
+
+                        if (TryResolveUrl(stringValue, resolvedUrl: out IHtmlContent? resolvedUrl))
+                        {
+                            attributes[i] = new TagHelperAttribute(
+                                attribute.Name,
+                                resolvedUrl,
+                                attribute.ValueStyle);
+                        }
+                        else if (htmlString == null)
+                        {
+                            // Not a ~/ URL. Just avoid re-encoding the attribute value later.
+                            attributes[i] = new TagHelperAttribute(
+                                attribute.Name,
+                                new HtmlString(stringValue),
+                                attribute.ValueStyle);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
+        /// </summary>
+        /// <param name="url">The URL to resolve.</param>
+        /// <param name="resolvedUrl">Absolute URL beginning with the application's virtual root. <c>null</c> if
+        /// <paramref name="url"/> could not be resolved.</param>
+        /// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
+        protected bool TryResolveUrl(string url, out string? resolvedUrl)
+        {
+            resolvedUrl = null;
+            var start = FindRelativeStart(url);
+            if (start == -1)
+            {
+                return false;
+            }
+
+            var trimmedUrl = CreateTrimmedString(url, start);
+
+            var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
+            resolvedUrl = urlHelper.Content(trimmedUrl);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
+        /// </summary>
+        /// <param name="url">The URL to resolve.</param>
+        /// <param name="resolvedUrl">
+        /// Absolute URL beginning with the application's virtual root. <c>null</c> if <paramref name="url"/> could
+        /// not be resolved.
+        /// </param>
+        /// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
+        protected bool TryResolveUrl(string url, [NotNullWhen(true)] out IHtmlContent? resolvedUrl)
+        {
+            resolvedUrl = null;
+            var start = FindRelativeStart(url);
+            if (start == -1)
+            {
+                return false;
+            }
+
+            var trimmedUrl = CreateTrimmedString(url, start);
+
+            var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
+            var appRelativeUrl = urlHelper.Content(trimmedUrl);
+            var postTildeSlashUrlValue = trimmedUrl.Substring(2);
+
+            if (!appRelativeUrl.EndsWith(postTildeSlashUrlValue, StringComparison.Ordinal))
+            {
+                throw new InvalidOperationException();
+            }
+
+            resolvedUrl = new EncodeFirstSegmentContent(
+                appRelativeUrl,
+                appRelativeUrl.Length - postTildeSlashUrlValue.Length,
+                postTildeSlashUrlValue);
+
+            return true;
+        }
+
+        private static int FindRelativeStart(string url)
+        {
+            if (url == null || url.Length < 2)
+            {
+                return -1;
+            }
+
+            var maxTestLength = url.Length - 2;
+
+            var start = 0;
+            for (; start < url.Length; start++)
+            {
+                if (start > maxTestLength)
+                {
+                    return -1;
+                }
+
+                if (!IsCharWhitespace(url[start]))
+                {
+                    break;
+                }
+            }
+
+            // Before doing more work, ensure that the URL we're looking at is app-relative.
+            if (url[start] != '~' || url[start + 1] != '/')
+            {
+                return -1;
+            }
+
+            return start;
+        }
+
+        private static string CreateTrimmedString(string input, int start)
+        {
+            var end = input.Length - 1;
+            for (; end >= start; end--)
+            {
+                if (!IsCharWhitespace(input[end]))
+                {
+                    break;
+                }
+            }
+
+            var len = end - start + 1;
+
+            // Substring returns same string if start == 0 && len == Length
+            return input.Substring(start, len);
+        }
+
+        private static bool IsCharWhitespace(char ch)
+        {
+            return ValidAttributeWhitespaceChars.AsSpan().IndexOf(ch) != -1;
+        }
+
+        private sealed class EncodeFirstSegmentContent : IHtmlContent
+        {
+            private readonly string _firstSegment;
+            private readonly int _firstSegmentLength;
+            private readonly string _secondSegment;
+
+            public EncodeFirstSegmentContent(string firstSegment, int firstSegmentLength, string secondSegment)
+            {
+                _firstSegment = firstSegment;
+                _firstSegmentLength = firstSegmentLength;
+                _secondSegment = secondSegment;
+            }
+
+            public void WriteTo(TextWriter writer, HtmlEncoder encoder)
+            {
+                encoder.Encode(writer, _firstSegment, 0, _firstSegmentLength);
+                writer.Write(_secondSegment);
+            }
+        }
+    }
+
+}

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -14,7 +14,7 @@
         <RepositoryType>git</RepositoryType>
     </PropertyGroup>
   <PropertyGroup>
-    <Version Condition=" '$(Version)' == '' ">1.6.0</Version>
+    <Version Condition=" '$(Version)' == '' ">1.7.2</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -28,8 +28,8 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="NBitcoin" Version="6.0.19" />
-      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.3.0" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.3.21" />
+      <PackageReference Include="NBitcoin" Version="7.0.24" />
       <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     </ItemGroup>
   <ItemGroup>

BTCPayServer.Client/BTCPayServerClient.APIKeys.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -22,6 +23,15 @@ namespace BTCPayServer.Client
             return await HandleResponse<ApiKeyData>(response);
         }
 
+        public virtual async Task<ApiKeyData> CreateAPIKey(string userId, CreateApiKeyRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}/api-keys",
+            bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<ApiKeyData>(response);
+        }
+
         public virtual async Task RevokeCurrentAPIKeyInfo(CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/api-keys/current", null, HttpMethod.Delete), token);
@@ -35,5 +45,14 @@ namespace BTCPayServer.Client
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/api-keys/{apikey}", null, HttpMethod.Delete), token);
             await HandleResponse(response);
         }
+        public virtual async Task RevokeAPIKey(string userId, string apikey, CancellationToken token = default)
+        {
+            if (apikey == null)
+                throw new ArgumentNullException(nameof(apikey));
+            if (userId is null)
+                throw new ArgumentNullException(nameof(userId));
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}/api-keys/{apikey}", null, HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Apps.cs

@@ -0,0 +1,103 @@
+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<CrowdfundAppData> CreateCrowdfundApp(string storeId,
+            CreateCrowdfundAppRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/apps/crowdfund", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<CrowdfundAppData>(response);
+        }
+
+        public virtual async Task<PointOfSaleAppData> UpdatePointOfSaleApp(string appId,
+            CreatePointOfSaleAppRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/apps/pos/{appId}", bodyPayload: request,
+                    method: HttpMethod.Put), 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<AppDataBase[]> GetAllApps(string storeId, CancellationToken token = default)
+        {
+            if (storeId == null)
+                throw new ArgumentNullException(nameof(storeId));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/apps",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<AppDataBase[]>(response);
+        }
+
+        public virtual async Task<AppDataBase[]> GetAllApps(CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/apps",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<AppDataBase[]>(response);
+        }
+
+        public virtual async Task<PointOfSaleAppData> GetPosApp(string appId, CancellationToken token = default)
+        {
+            if (appId == null)
+                throw new ArgumentNullException(nameof(appId));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/apps/pos/{appId}",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<PointOfSaleAppData>(response);
+        }
+
+        public virtual async Task<CrowdfundAppData> GetCrowdfundApp(string appId, CancellationToken token = default)
+        {
+            if (appId == null)
+                throw new ArgumentNullException(nameof(appId));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/apps/crowdfund/{appId}",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<CrowdfundAppData>(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,102 @@
+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> GetCustodianAccountDepositAddress(string storeId, string accountId, string paymentMethod, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/addresses/{paymentMethod}"), token);
+            return await HandleResponse<DepositAddressData>(response);
+        }
+
+        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> GetCustodianAccountTradeInfo(string storeId, string accountId, string tradeId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/{tradeId}", method: HttpMethod.Get), token);
+            return await HandleResponse<MarketTradeResponseData>(response);
+        }
+
+        public virtual async Task<TradeQuoteResponseData> GetCustodianAccountTradeQuote(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> CreateCustodianAccountWithdrawal(string storeId, string accountId,  WithdrawRequestData request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals", bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<WithdrawalResponseData>(response);
+        }
+        
+        public virtual async Task<WithdrawalSimulationResponseData> SimulateCustodianAccountWithdrawal(string storeId, string accountId, WithdrawRequestData request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals/simulation", bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<WithdrawalSimulationResponseData>(response);
+        }
+
+        public virtual async Task<WithdrawalResponseData> GetCustodianAccountWithdrawalInfo(string storeId, string accountId, string paymentMethod, string withdrawalId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals/{paymentMethod}/{withdrawalId}", method: HttpMethod.Get), token);
+            return await HandleResponse<WithdrawalResponseData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.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

@@ -128,5 +128,18 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Post), token);
             await HandleResponse(response);
         }
+
+        public virtual async Task<PullPaymentData> RefundInvoice(
+            string storeId,
+            string invoiceId,
+            RefundInvoiceRequest request,
+            CancellationToken token = default
+        )
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/refund", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<PullPaymentData>(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -18,6 +18,15 @@ namespace BTCPayServer.Client
             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 virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
             CancellationToken token = default)
         {
@@ -54,8 +63,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<string>(response);
         }
 
-
-        public virtual async Task PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
+        public virtual async Task<LightningPaymentData> PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -63,7 +71,18 @@ 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 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,
@@ -77,6 +96,42 @@ namespace BTCPayServer.Client
             return await HandleResponse<LightningInvoiceData>(response);
         }
 
+        public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string cryptoCode,
+            bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (pendingOnly is bool v)
+            {
+                queryPayload.Add("pendingOnly", v.ToString());
+            }
+            if (offsetIndex is > 0)
+            {
+                queryPayload.Add("offsetIndex", offsetIndex);
+            }
+
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices", queryPayload), token);
+            return await HandleResponse<LightningInvoiceData[]>(response);
+        }
+        
+        public virtual async Task<LightningPaymentData[]> GetLightningPayments(string cryptoCode,
+            bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (includePending is bool v)
+            {
+                queryPayload.Add("includePending", v.ToString());
+            }
+            if (offsetIndex is > 0)
+            {
+                queryPayload.Add("offsetIndex", offsetIndex);
+            }
+
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/payments", queryPayload), token);
+            return await HandleResponse<LightningPaymentData[]>(response);
+        }
+
         public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
             CancellationToken token = default)
         {

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

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

BTCPayServer.Client/BTCPayServerClient.LightningAddresses.cs

@@ -0,0 +1,48 @@
+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<LightningAddressData[]> GetStoreLightningAddresses(string storeId,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning-addresses",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningAddressData[]>(response);
+        }
+
+        public virtual async Task<LightningAddressData> GetStoreLightningAddress(string storeId, string username,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning-addresses/{username}",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningAddressData>(response);
+        }
+
+        public virtual async Task RemoveStoreLightningAddress(string storeId, string username,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning-addresses/{username}",
+                    method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<LightningAddressData> AddOrUpdateStoreLightningAddress(string storeId,
+            string username, LightningAddressData data,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning-addresses/{username}",
+                    method: HttpMethod.Post, bodyPayload: data), token);
+
+            return await HandleResponse<LightningAddressData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.OnChainPaymentMethods.cs

@@ -20,7 +20,7 @@ namespace BTCPayServer.Client
 
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain",
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain",
                         query), token);
             return await HandleResponse<IEnumerable<OnChainPaymentMethodData>>(response);
         }
@@ -30,7 +30,7 @@ namespace BTCPayServer.Client
         {
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}"), token);
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}"), token);
             return await HandleResponse<OnChainPaymentMethodData>(response);
         }
 
@@ -39,7 +39,7 @@ namespace BTCPayServer.Client
         {
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}",
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}",
                         method: HttpMethod.Delete), token);
             await HandleResponse(response);
         }
@@ -49,7 +49,7 @@ namespace BTCPayServer.Client
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}",
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}",
                     bodyPayload: paymentMethod, method: HttpMethod.Put), token);
             return await HandleResponse<OnChainPaymentMethodData>(response);
         }
@@ -61,7 +61,7 @@ namespace BTCPayServer.Client
                 CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/preview",
+                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);
@@ -73,7 +73,7 @@ namespace BTCPayServer.Client
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/preview",
+                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);
@@ -84,7 +84,7 @@ namespace BTCPayServer.Client
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/generate",
+                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.Objects.cs

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

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.cs

@@ -16,7 +16,7 @@ namespace BTCPayServer.Client
         {
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/wallet"), token);
+                    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,
@@ -29,7 +29,7 @@ namespace BTCPayServer.Client
             }
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/wallet/feeRate", queryParams), token);
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/feeRate", queryParams), token);
             return await HandleResponse<OnChainWalletFeeRateData>(response);
         }
 
@@ -38,7 +38,7 @@ namespace BTCPayServer.Client
         {
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/wallet/address", new Dictionary<string, object>()
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", new Dictionary<string, object>()
                     {
                         {"forceGenerate", forceGenerate}
                     }), token);
@@ -50,12 +50,12 @@ namespace BTCPayServer.Client
         {
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/wallet/address", method: HttpMethod.Delete), token);
+                    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 storeId, string cryptoCode, TransactionStatus[] statusFilter = null, string labelFilter = null,
             CancellationToken token = default)
         {
             var query = new Dictionary<string, object>();
@@ -63,9 +63,13 @@ namespace BTCPayServer.Client
             {
                 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);
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", query), token);
             return await HandleResponse<IEnumerable<OnChainWalletTransactionData>>(response);
         }
 
@@ -75,7 +79,21 @@ namespace BTCPayServer.Client
         {
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/wallet/transactions/{transactionId}"), token);
+                    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);
         }
 
@@ -85,7 +103,7 @@ namespace BTCPayServer.Client
         {
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/wallet/utxos"), token);
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/utxos"), token);
             return await HandleResponse<IEnumerable<OnChainWalletUTXOData>>(response);
         }
 
@@ -100,7 +118,7 @@ namespace BTCPayServer.Client
             }
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/wallet/transactions", null, request, HttpMethod.Post), token);
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", null, request, HttpMethod.Post), token);
             return await HandleResponse<OnChainWalletTransactionData>(response);
         }
 
@@ -115,7 +133,7 @@ namespace BTCPayServer.Client
             }
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/wallet/transactions", null, request, HttpMethod.Post), token);
+                    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

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

BTCPayServer.Client/BTCPayServerClient.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

@@ -41,12 +41,33 @@ namespace BTCPayServer.Client
             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 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> GetPullPaymentPayout(string pullPaymentId, string payoutId, CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts/{payoutId}", method: HttpMethod.Get), cancellationToken);
+            return await HandleResponse<PayoutData>(response);
+        }
+        public virtual async Task<PayoutData> GetStorePayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payouts/{payoutId}", method: HttpMethod.Get), cancellationToken);
+            return await HandleResponse<PayoutData>(response);
+        }
+        public virtual async Task<PayoutData> CreatePayout(string storeId, CreatePayoutThroughStoreRequest payoutRequest, CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payouts", bodyPayload: payoutRequest, method: HttpMethod.Post), cancellationToken);
+            return await HandleResponse<PayoutData>(response);
+        }
         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);
@@ -58,7 +79,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<PayoutData>(response);
         }
 
-        public async Task MarkPayoutPaid(string storeId, string payoutId,
+        public virtual async Task MarkPayoutPaid(string storeId, string payoutId,
             CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(
@@ -67,5 +88,24 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Post), cancellationToken);
             await HandleResponse(response);
         }
+        public virtual async Task MarkPayout(string storeId, string payoutId, MarkPayoutRequest request,
+            CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest(
+                    $"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark",
+                    method: HttpMethod.Post, bodyPayload: request), cancellationToken);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<PullPaymentLNURL> GetPullPaymentLNURL(string pullPaymentId,
+            CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest(
+                    $"/api/v1/pull-payments/{pullPaymentId}/lnurl",
+                    method: HttpMethod.Get), cancellationToken);
+            return await HandleResponse<PullPaymentLNURL>(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.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.StoreRatesConfiguration.cs

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

BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

@@ -23,7 +23,7 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public virtual async Task<StoreData> AddStoreUser(string storeId, StoreUserData request,
+        public virtual async Task AddStoreUser(string storeId, StoreUserData request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -31,7 +31,7 @@ namespace BTCPayServer.Client
             using var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/stores/{storeId}/users", bodyPayload: request, method: HttpMethod.Post),
                 token);
-            return await HandleResponse<StoreData>(response);
+            await HandleResponse(response);
         }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Users.cs

@@ -27,6 +27,26 @@ namespace BTCPayServer.Client
             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<bool> 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);
+            return response.IsSuccessStatusCode;
+        }
+
+        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/JsonConverters/TradeQuantityJsonConverter.cs

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

BTCPayServer.Client/Models/AddCustomerEmailRequest.cs

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

BTCPayServer.Client/Models/ApplicationUserData.cs

@@ -35,5 +35,7 @@ namespace BTCPayServer.Client.Models
         /// </summary>
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset? Created { get; set; }
+
+        public bool Disabled { get; set; }
     }
 }

BTCPayServer.Client/Models/AssetPairData.cs

@@ -0,0 +1,33 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+[JsonObject(MemberSerialization.OptIn)]
+public class AssetPairData
+{
+    public AssetPairData()
+    {
+    }
+
+    public AssetPairData(string assetBought, string assetSold, decimal minimumTradeQty)
+    {
+        AssetBought = assetBought;
+        AssetSold = assetSold;
+        MinimumTradeQty = minimumTradeQty;
+    }
+
+    [JsonProperty]
+    public string AssetBought { set; get; }
+
+    [JsonProperty]
+    public string AssetSold { set; get; }
+
+    [JsonProperty]
+    public decimal MinimumTradeQty { set; get; }
+
+
+    public override string ToString()
+    {
+        return AssetBought + "/" + AssetSold;
+    }
+}

BTCPayServer.Client/Models/CreateAppRequest.cs

@@ -0,0 +1,84 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models
+{
+    public enum PosViewType
+    {
+        Static,
+        Cart,
+        Light,
+        Print
+    }
+
+    public class CreateAppRequest
+    {
+        public string AppName { get; set; }
+        public string AppType { get; set; }
+    }
+
+    public class CreatePointOfSaleAppRequest : CreateAppRequest
+    {
+        public string Currency { get; set; } = null;
+        public string Title { get; set; } = null;
+        public string Description { get; set; } = null;
+        public string Template { get; set; } = null;
+        [JsonConverter(typeof(StringEnumConverter))]
+        public PosViewType DefaultView { get; set; }
+        public bool ShowCustomAmount { get; set; } = false;
+        public bool ShowDiscount { get; set; } = true;
+        public bool EnableTips { get; set; } = true;
+        public string CustomAmountPayButtonText { get; set; } = null;
+        public string FixedAmountPayButtonText { get; set; } = null;
+        public string TipText { get; set; } = null;
+        public string CustomCSSLink { get; set; } = null;
+        public string NotificationUrl { get; set; } = null;
+        public string RedirectUrl { get; set; } = null;
+        public bool? RedirectAutomatically { get; set; } = null;
+        public bool? RequiresRefundEmail { get; set; } = null;
+        public string FormId { get; set; } = null;
+        public string EmbeddedCSS { get; set; } = null;
+        public CheckoutType? CheckoutType { get; set; } = null;
+    }
+
+    public enum CrowdfundResetEvery
+    {
+        Never,
+        Hour,
+        Day,
+        Month,
+        Year
+    }
+
+    public class CreateCrowdfundAppRequest : CreateAppRequest
+    {
+        public string Title { get; set; } = null;
+        public bool? Enabled { get; set; } = null;
+        public bool? EnforceTargetAmount { get; set; } = null;
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? StartDate { get; set; } = null;
+        public string TargetCurrency { get; set; } = null;
+        public string Description { get; set; } = null;
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? EndDate { get; set; } = null;
+        public decimal? TargetAmount { get; set; } = null;
+        public string CustomCSSLink { get; set; } = null;
+        public string MainImageUrl { get; set; } = null;
+        public string EmbeddedCSS { get; set; } = null;
+        public string NotificationUrl { get; set; } = null;
+        public string Tagline { get; set; } = null;
+        public string PerksTemplate { get; set; } = null;
+        public bool? SoundsEnabled { get; set; } = null;
+        public string DisqusShortname { get; set; } = null;
+        public bool? AnimationsEnabled { get; set; } = null;
+        public int? ResetEveryAmount { get; set; } = null;
+        [JsonConverter(typeof(StringEnumConverter))]
+        public CrowdfundResetEvery ResetEvery { get; set; } = CrowdfundResetEvery.Never;
+        public bool? DisplayPerksValue { get; set; } = null;
+        public bool? DisplayPerksRanking { get; set; } = null;
+        public bool? SortPerksByPopularity { get; set; } = null;
+        public string[] Sounds { get; set; } = null;
+        public string[] AnimationColors { get; set; } = null;
+    }
+}

BTCPayServer.Client/Models/CreateCustodianAccountRequest.cs

@@ -0,0 +1,12 @@
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models
+{
+    public class CreateCustodianAccountRequest
+    {
+        public string CustodianCode { get; set; }
+        public string Name { get; set; }
+
+        public JObject Config { get; set; }
+    }
+}

BTCPayServer.Client/Models/CreateLightningInvoiceRequest.cs

@@ -1,6 +1,6 @@
 using System;
 using BTCPayServer.Lightning;
-using BTCPayServer.Lightning.JsonConverters;
+using NBitcoin;
 using Newtonsoft.Json;
 
 namespace BTCPayServer.Client.Models
@@ -11,15 +11,18 @@ namespace BTCPayServer.Client.Models
         {
 
         }
+
         public CreateLightningInvoiceRequest(LightMoney amount, string description, TimeSpan expiry)
         {
             Amount = amount;
             Description = description;
             Expiry = expiry;
         }
-        [JsonConverter(typeof(BTCPayServer.Client.JsonConverters.LightMoneyJsonConverter))]
+
+        [JsonConverter(typeof(JsonConverters.LightMoneyJsonConverter))]
         public LightMoney Amount { get; set; }
         public string Description { get; set; }
+        public bool DescriptionHashOnly { get; set; }
         [JsonConverter(typeof(JsonConverters.TimeSpanJsonConverter.Seconds))]
         public TimeSpan Expiry { get; set; }
         public bool PrivateRouteHints { get; set; }

BTCPayServer.Client/Models/CreateOnChainTransactionRequest.cs

@@ -26,5 +26,6 @@ namespace BTCPayServer.Client.Models
         public List<CreateOnChainTransactionRequestDestination> Destinations { get; set; }
         [JsonProperty("rbf")]
         public bool? RBF { get; set; } = null;
+        public bool ExcludeUnconfirmed { get; set; } = false;
     }
 }

BTCPayServer.Client/Models/CreatePayoutThroughStoreRequest.cs

@@ -0,0 +1,8 @@
+#nullable enable
+namespace BTCPayServer.Client.Models;
+
+public class CreatePayoutThroughStoreRequest : CreatePayoutRequest
+{
+    public string? PullPaymentId { get; set; }
+    public bool? Approved { get; set; }
+}

BTCPayServer.Client/Models/CreatePullPaymentRequest.cs

@@ -22,5 +22,6 @@ namespace BTCPayServer.Client.Models
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset? StartsAt { get; set; }
         public string[] PaymentMethods { get; set; }
+        public bool AutoApproveClaims { get; set; }
     }
 }

BTCPayServer.Client/Models/CustodianAccountBaseData.cs

@@ -0,0 +1,16 @@
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models
+{
+    public abstract class CustodianAccountBaseData
+    {
+        public string CustodianCode { get; set; }
+
+        public string Name { get; set; }
+
+        public string StoreId { get; set; }
+
+        public JObject Config { get; set; }
+    }
+
+}

BTCPayServer.Client/Models/CustodianAccountData.cs

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

BTCPayServer.Client/Models/CustodianAccountResponse.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models;
+
+public class CustodianAccountResponse : CustodianAccountData
+{
+    public IDictionary<string, decimal> AssetBalances { get; set; }
+
+    public CustodianAccountResponse()
+    {
+
+    }
+
+}

BTCPayServer.Client/Models/CustodianData.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models;
+
+public class CustodianData
+{
+    public string Code { get; set; }
+    public string Name { get; set; }
+    public Dictionary<string, AssetPairData> TradableAssetPairs { get; set; }
+    public string[] WithdrawablePaymentMethods { get; set; }
+    public string[] DepositablePaymentMethods { get; set; }
+
+}