Update changelog

* WIP New APIs for dealing with custodians/exchanges

* Simplified things

* More API refinements + index.html file for quick viewing

* Finishing touches on spec

* Switched cryptoCode to paymentMethod as this allows us to differentiate between onchain and lightning

* Moved draft API docs to "/docs-draft"

* WIP baby steps

* Added DB migration for CustodianAccountData

* Rough but working POST /v1/api/custodian-account + GET /v1/api/custodian

* WIP + early Kraken API client

* Moved service registration to proper location

* Working create + list custodian accounts + permissions + WIP Kraken client

* Kraken API Balances call is working

* Added asset balances to response

* List Custodian Accounts call does not load assetBalances by default, because it can fail. Can be requested when needed.

* Call to get the details of 1 specific custodian account

* Added permissions to swagger

* Added "tradableAssetPairs" to Kraken custodian response + cache the tradable pairs in memory for 24 hours

* Removed unused file

* WIP + Moved files to better locations

* Updated docs

* Working API endpoint to get info on a trade (same response as creating a new trade)

* Working API endpoints for Deposit + Trade + untested Withdraw

* Delete custodian account

* Trading works, better error handling, cleanup

* Working withdrawals + New endpoint for getting bid/ask prices

* Completed withdrawals + new endpoint for getting info on a past withdrawal to simplify testing, Enums are output as strings,

* Better error handling when withdrawing to a wrong destination

* WithdrawalAddressName in config is now a string per currency (dictionary)

* Added TODOs

* Only show the custodian account "config" to users who are allowed

* Added the new permissions to the API Keys UI

* Renamed KrakenClient to KrakenExchange

* WIP Kraken Config Form

* Removed files for UI again, will make separate PR later

* Fixed docs + Refactored to use PaymentMethod more + Added "name" to custodian account + Using cancelationToken everywhere

* Updated withdrawal info docs

* First unit test

* Complete tests for /api/v1/custodians and /api/v1/custodian-accounts endpoints + Various improvements and fixes

* Mock custodian and more exceptions

* Many more tests + cleanup, moved files to better locations

* More tests

* WIP more tests

* Greenfield API tests complete

* Added missing "Name" column

* Cleanup, TODOs and beginning of Kraken Tests

* Added Kraken tests using public endpoints + handling of "SATS" currency

* Added 1st mocked Kraken API call: GetAssetBalancesAsync

* Added assert for bad config

* Mocked more Kraken API responses + added CreationDate to withdrawal response

* pr review club changes

* Make Kraken Custodian a plugin

* Re-added User-Agent header as it is required

* Fixed bug in market trade on Kraken using a percentage as qty

* A short delay so Kraken has the time to execute the market order and we don't fetch the details too quickly.

* Merged the draft swagger into the main swagger since it didn't work anymore

* Fixed API permissions test

* Removed 2 TODOs

* Fixed unit test

* After a utxo rescan, the cached balance should be invalidated

* Fixed Kraken plugin build issues

* Added Kraken plugin to build

* WIP UI + config form

* Create custodian account almost working - only need to add in the config form

* Working form, but lacks refinement

* Viewing balances + Editing custodian account works, but cannot change the withdrawal destination config because that is an object using a name with [] in it

* cleanup

* Minor cleanup, comments

* Working: Delete custodian account

* Moved the MockCustodian used in tests to a new plugin + linked it to the tests

* WIP viewing custodian account balances

* Split the Mock custodian into a Mock + Fake, various UI improvements and minor fixes

* Minor UI fixes

* Removed broken link

* Removed links to anchors as they cannot pass the tests since they use JavaScript

* Removed non-existing link. Even though it was commented out, the test still broke?

* Added TODOs

* Now throwing BadConfigException if API key is invalid

* UI improvements

* Commented out unfinished API endpoints. Can be finished later.

* Show fiat value for fiat assets

* Removed Kraken plugin so I can make a PR


Removed more Kraken files

* Add experimental route on UICustodianAccountsControllre

* Removed unneeded code

* Cleanup code

* Processed Nicolas' feedback

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

.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,19 +26,18 @@ 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
@@ -51,9 +50,9 @@ jobs:
 
   arm32v7:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
-      - checkout  
+      - checkout
       - run:
           command: |
             sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
@@ -67,9 +66,9 @@ jobs:
 
   arm64v8:
     machine:
-        enabled: true
+      image: ubuntu-2004:202111-02
     steps:
-      - checkout  
+      - checkout
       - run:
           command: |
             sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
@@ -83,15 +82,10 @@ jobs:
 
   multiarch:
     machine:
-      enabled: true
-      image: circleci/classic:201808-01
+      image: ubuntu-2004:202201-02
     steps:
       - run:
           command: |
-            # Turn on Experimental features
-            sudo mkdir $HOME/.docker
-            sudo sh -c 'echo "{ \"experimental\": \"enabled\" }" >> $HOME/.docker/config.json'
-            #
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             #
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
@@ -100,8 +94,7 @@ jobs:
             sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 --os linux --arch arm --variant v7
             sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 --os linux --arch arm64 --variant v8
             sudo docker manifest push $DOCKERHUB_REPO:$LATEST_TAG -p
-            
-            
+
             sudo docker manifest create --amend $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8
             sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 --os linux --arch amd64
             sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 --os linux --arch arm --variant v7

.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

.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,11 @@
-blank_issues_enabled: false
-contact_links: 
-  - name: 🚀 Discussions  
+blank_issues_enabled: true
+contact_links:
+  - name: 🚀 Discussions
     url: https://github.com/btcpayserver/btcpayserver/discussions
-    about: Technical discussions, questions and feature requests    
+    about: Technical discussions, questions and feature requests
   - name: 📝 Official Documentation
     url: https://docs.btcpayserver.org
-    about: Check our documentation for answers to common questions 
-  - name: 💬 Community Support Chat  
+    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

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -31,9 +31,10 @@
     <None Include="icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="HtmlSanitizer" Version="5.0.372" />
     <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="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.3" />
     <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="6.0.0" />
   </ItemGroup>
   <ItemGroup>

BTCPayServer.Abstractions/Configuration/DataDirectories.cs

@@ -6,7 +6,6 @@ namespace BTCPayServer.Configuration
         public string PluginDir { get; set; }
         public string TempStorageDir { get; set; }
         public string StorageDir { get; set; }
+        public string TempDir { get; set; }
     }
-
-
 }

BTCPayServer.Abstractions/Constants/WellKnownTempData.cs

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

BTCPayServer.Abstractions/Contracts/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/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,10 @@
+#nullable enable
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IStoreRepository
+{
+    Task<T?> GetSettingAsync<T>(string storeId, 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/Custodians/Client/AssetQuoteResult.cs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

BTCPayServer.Abstractions/Custodians/Client/MarketTradeResult.cs

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

BTCPayServer.Abstractions/Custodians/Client/WithdrawResult.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+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,32 @@
+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 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,14 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+public interface ICanWithdraw
+{
+    public Task<WithdrawResult> WithdrawAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken);
+
+    public Task<WithdrawResult> GetWithdrawalInfoAsync(string paymentMethod, string withdrawalId, JObject config, CancellationToken cancellationToken);
+
+    public string[] GetWithdrawablePaymentMethods();
+}

BTCPayServer.Abstractions/Custodians/ICustodian.cs

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

BTCPayServer.Abstractions/Extensions/CustodianExtensions.cs

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

BTCPayServer.Abstractions/Extensions/Extensions.cs

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

BTCPayServer.Abstractions/Extensions/GreenfieldExtensions.cs

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

BTCPayServer.Abstractions/Extensions/HttpRequestExtensions.cs

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

BTCPayServer.Abstractions/Extensions/ITempDataDictionaryExtensions.cs

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

BTCPayServer.Abstractions/Extensions/StringExtensions.cs

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

BTCPayServer.Abstractions/Extensions/ViewsRazor.cs

@@ -90,7 +90,7 @@ namespace BTCPayServer.Abstractions.Extensions
         public static string ToTimeAgo(this DateTimeOffset date)
         {
             var diff = DateTimeOffset.UtcNow - date;
-            var formatted = diff.Seconds > 0
+            var formatted = diff.TotalSeconds > 0
                 ? $"{diff.TimeString()} ago"
                 : $"in {diff.Negate().TimeString()}";
             return formatted;
@@ -113,9 +113,9 @@ namespace BTCPayServer.Abstractions.Extensions
             return $"{(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 ? "s" : string.Empty;
         }
     }
 }

BTCPayServer.Abstractions/Form/AlertMessage.cs

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

BTCPayServer.Abstractions/Form/Field.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public abstract class Field
+{
+    // HTML5 compatible type string like "text", "textarea", "email", "password", etc. Each type is a class and may contain more fields (i.e. "select" would have options).
+    public string Type;
+    
+    // The name of the HTML5 node. Should be used as the key for the posted data.
+    public string Name;
+    
+    // The translated label of the field.
+    public string Label;
+    
+    // The value field is what is currently in the DB or what the user entered, but possibly not saved yet due to validation errors.
+    // If this is the first the user sees the form, then value and original value are the same. Value changes as the user starts interacting with the form.
+    public string Value;
+
+    // The original value is the value that is currently saved in the backend. A "reset" button can be used to revert back to this. Should only be set from the constructor.
+    public string OriginalValue;
+
+    // A useful note shown below the field or via a tooltip / info icon. Should be translated for the user.
+    public string HelpText;
+    
+    // The field is considered "valid" if there are no validation errors
+    public List<string> ValidationErrors = new List<string>();
+
+    public bool Required = false;
+
+    public bool IsValid()
+    {
+        return ValidationErrors.Count == 0;
+    }
+}

BTCPayServer.Abstractions/Form/Fieldset.cs

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

BTCPayServer.Abstractions/Form/Form.cs

@@ -0,0 +1,60 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public class Form
+{
+
+    // Messages to be shown at the top of the form indicating user feedback like "Saved successfully" or "Please change X because of Y." or a warning, etc...
+    public List<AlertMessage> TopMessages { get; set; } = new();
+    
+    // Groups of fields in the form
+    public List<Fieldset> Fieldsets { get; set; } = new();
+    
+
+    // Are all the fields valid in the form?
+    public bool IsValid()
+    {
+        foreach (var fieldset in Fieldsets)
+        {
+            foreach (var field in fieldset.Fields)
+            {
+                if (!field.IsValid())
+                {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public Field GetFieldByName(string name)
+    {
+        foreach (var fieldset in Fieldsets)
+        {
+            foreach (var field in fieldset.Fields)
+            {
+                if (name.Equals(field.Name))
+                {
+                    return field;
+                }
+            }
+        }
+        return null;
+    }
+
+    public List<string> GetAllNames()
+    {
+        var names = new List<string>();
+        foreach (var fieldset in Fieldsets)
+        {
+            foreach (var field in fieldset.Fields)
+            {
+                names.Add(field.Name);
+            }
+        }
+
+        return names;
+    }
+}

BTCPayServer.Abstractions/Form/TextField.cs

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

BTCPayServer.Abstractions/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.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.0</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.7" />
+      <PackageReference Include="NBitcoin" Version="7.0.1" />
       <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     </ItemGroup>
   <ItemGroup>

BTCPayServer.Client/BTCPayServerClient.Apps.cs

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

BTCPayServer.Client/BTCPayServerClient.CustodianAccounts.cs

@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<IEnumerable<CustodianAccountData>> GetCustodianAccounts(string storeId, bool includeAssetBalances = false, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (includeAssetBalances)
+            {
+                queryPayload.Add("assetBalances", "true");
+            }
+
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts", queryPayload), token);
+            return await HandleResponse<IEnumerable<CustodianAccountData>>(response);
+        }
+
+        public virtual async Task<CustodianAccountResponse> GetCustodianAccount(string storeId, string accountId, bool includeAssetBalances = false, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (includeAssetBalances)
+            {
+                queryPayload.Add("assetBalances", "true");
+            }
+
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", queryPayload), token);
+            return await HandleResponse<CustodianAccountResponse>(response);
+        }
+
+        public virtual async Task<CustodianAccountData> CreateCustodianAccount(string storeId, CreateCustodianAccountRequest request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts", bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<CustodianAccountData>(response);
+        }
+
+        public virtual async Task<CustodianAccountData> UpdateCustodianAccount(string storeId, string accountId, CreateCustodianAccountRequest request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", bodyPayload: request, method: HttpMethod.Put), token);
+            return await HandleResponse<CustodianAccountData>(response);
+        }
+
+        public virtual async Task DeleteCustodianAccount(string storeId, string accountId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<DepositAddressData> GetDepositAddress(string storeId, string accountId, string paymentMethod, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/addresses/{paymentMethod}"), token);
+            return await HandleResponse<DepositAddressData>(response);
+        }
+
+        public virtual async Task<MarketTradeResponseData> TradeMarket(string storeId, string accountId, TradeRequestData request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/market", bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<MarketTradeResponseData>(response);
+        }
+
+        public virtual async Task<MarketTradeResponseData> GetTradeInfo(string storeId, string accountId, string tradeId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/{tradeId}", method: HttpMethod.Get), token);
+            return await HandleResponse<MarketTradeResponseData>(response);
+        }
+
+        public virtual async Task<TradeQuoteResponseData> GetTradeQuote(string storeId, string accountId, string fromAsset, string toAsset, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            queryPayload.Add("fromAsset", fromAsset);
+            queryPayload.Add("toAsset", toAsset);
+
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/quote", queryPayload), token);
+            return await HandleResponse<TradeQuoteResponseData>(response);
+        }
+        
+        public virtual async Task<WithdrawalResponseData> CreateWithdrawal(string storeId, string accountId,  WithdrawRequestData request, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals", bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<WithdrawalResponseData>(response);
+        }
+
+        public virtual async Task<WithdrawalResponseData> GetWithdrawalInfo(string storeId, string accountId, string paymentMethod, string withdrawalId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals/{paymentMethod}/{withdrawalId}", method: HttpMethod.Get), token);
+            return await HandleResponse<WithdrawalResponseData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Custodians.cs

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

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -17,6 +17,15 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Get), token);
             return await HandleResponse<LightningNodeInformationData>(response);
         }
+        
+        public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/balance",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeBalanceData>(response);
+        }
 
         public 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,

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -17,6 +17,15 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Get), token);
             return await HandleResponse<LightningNodeInformationData>(response);
         }
+        
+        public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string storeId, string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/balance",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeBalanceData>(response);
+        }
 
         public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
             CancellationToken token = default)
@@ -67,6 +76,17 @@ namespace BTCPayServer.Client
             await HandleResponse(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,
             string invoiceId, CancellationToken token = default)
         {

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.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,12 @@ 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 +78,18 @@ 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,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}", queryPayload: null, bodyPayload: request, HttpMethod.Patch), token);
             return await HandleResponse<OnChainWalletTransactionData>(response);
         }
 
@@ -85,7 +99,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 +114,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 +129,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.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,23 @@ 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> 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);

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.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,25 @@ 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 LockUser(string idOrEmail, bool locked, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}/lock", null,
+                new LockUserRequest() {Locked = locked}, HttpMethod.Post), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<ApplicationUserData[]> GetUsers( CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/", null, HttpMethod.Get), token);
+            return await HandleResponse<ApplicationUserData[]>(response);
+        }
+
         public virtual async Task DeleteCurrentUser(CancellationToken token = default)
         {
             await DeleteUser("me", token);

BTCPayServer.Client/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,22 @@
+namespace BTCPayServer.Client.Models;
+
+public class AssetPairData
+{
+    public AssetPairData()
+    {
+    }
+    
+    public AssetPairData(string assetBought, string assetSold)
+    {
+        AssetBought = assetBought;
+        AssetSold = assetSold;
+    }
+    
+    public string AssetBought { set; get; }
+    public string AssetSold { set; get; }
+
+    public override string ToString()
+    {
+        return AssetBought + "/" + AssetSold;
+    }
+}

BTCPayServer.Client/Models/CreateAppRequest.cs

@@ -0,0 +1,41 @@
+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; } = true;
+        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 EmbeddedCSS { 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,19 @@ 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; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.UInt256JsonConverter))]
+        public uint256 DescriptionHash { 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,11 @@
+namespace BTCPayServer.Client.Models;
+
+public class CustodianData
+{
+    public string Code { get; set; }
+    public string Name { get; set; }
+    public string[] TradableAssetPairs { get; set; }
+    public string[] WithdrawablePaymentMethods { get; set; }
+    public string[] DepositablePaymentMethods { get; set; }
+    
+}

BTCPayServer.Client/Models/DepositAddressData.cs

@@ -0,0 +1,15 @@
+namespace BTCPayServer.Client.Models;
+
+public class DepositAddressData
+{
+    // /**
+    // * Example: P2PKH, P2SH, P2WPKH, P2TR, BOLT11, ...
+    // */
+    // public string Type { get; set; }
+    
+    /**
+     * Format depends hugely on the type.
+     */
+    public string Address { get; set; }
+    
+}

BTCPayServer.Client/Models/EmailSettingsData.cs

@@ -0,0 +1,29 @@
+namespace BTCPayServer.Client.Models;
+
+public class EmailSettingsData
+{
+    public string Server
+    {
+        get; set;
+    }
+
+    public int? Port
+    {
+        get; set;
+    }
+
+    public string Login
+    {
+        get; set;
+    }
+
+    public string Password
+    {
+        get; set;
+    }
+    public string From
+    {
+        get; set;
+    }
+    public bool DisableCertificateCheck { get; set; }
+}

BTCPayServer.Client/Models/InvoiceData.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using BTCPayServer.Client.JsonConverters;
 using BTCPayServer.JsonConverters;
 using Newtonsoft.Json;
@@ -19,6 +20,48 @@ namespace BTCPayServer.Client.Models
         public string Currency { get; set; }
         public JObject Metadata { get; set; }
         public CheckoutOptions Checkout { get; set; } = new CheckoutOptions();
+        public ReceiptOptions Receipt { get; set; } = new ReceiptOptions();
+
+        public class ReceiptOptions
+        {
+            public bool? Enabled { get; set; }
+            public bool? ShowQR { get; set; }
+            public bool? ShowPayments { get; set; }
+            [JsonExtensionData]
+            public IDictionary<string, JToken> AdditionalData { get; set; }
+
+#nullable enable
+            /// <summary>
+            /// Make sure that the return has all values set by order of priority: invoice/store/default
+            /// </summary>
+            /// <param name="storeLevelOption"></param>
+            /// <param name="invoiceLevelOption"></param>
+            /// <returns></returns>
+            public static ReceiptOptions Merge(ReceiptOptions? storeLevelOption, ReceiptOptions? invoiceLevelOption)
+            {
+                storeLevelOption ??= new ReceiptOptions();
+                invoiceLevelOption ??= new ReceiptOptions();
+                var store = JObject.FromObject(storeLevelOption);
+                var inv = JObject.FromObject(invoiceLevelOption);
+                var result = JObject.FromObject(CreateDefault());
+                var mergeSettings = new JsonMergeSettings() { MergeNullValueHandling = MergeNullValueHandling.Ignore };
+                result.Merge(store, mergeSettings);
+                result.Merge(inv, mergeSettings);
+                var options = result.ToObject<ReceiptOptions>()!;
+                return options;
+            }
+
+            public static ReceiptOptions CreateDefault()
+            {
+                return new ReceiptOptions()
+                {
+                    ShowQR = true,
+                    Enabled = true,
+                    ShowPayments = true
+                };
+            }
+#nullable restore
+        }
         public class CheckoutOptions
         {
 

BTCPayServer.Client/Models/InvoicePaymentMethodDataModel.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using BTCPayServer.JsonConverters;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client.Models
 {
@@ -34,6 +35,7 @@ namespace BTCPayServer.Client.Models
         public string PaymentMethod { get; set; }
 
         public string CryptoCode { get; set; }
+        public JObject AdditionalData { get; set; }
 
         public class Payment
         {

BTCPayServer.Client/Models/LedgerEntryData.cs

@@ -0,0 +1,27 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models;
+
+public class LedgerEntryData
+{
+    public string Asset { get; }
+    public decimal Qty { get; }
+
+    [JsonConverter(typeof(StringEnumConverter))]
+    public LedgerEntryType Type { get; }
+
+    public LedgerEntryData(string asset, decimal qty, LedgerEntryType type)
+    {
+        Asset = asset;
+        Qty = qty;
+        Type = type;
+    }
+
+    public enum LedgerEntryType
+    {
+        Trade = 0,
+        Fee = 1,
+        Withdrawal = 2
+    }
+}

BTCPayServer.Client/Models/LightningAutomatedPayoutSettings.cs

@@ -0,0 +1,13 @@
+using System;
+using BTCPayServer.Client.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class LightningAutomatedPayoutSettings
+{
+    public string PaymentMethod { get; set; }
+        
+    [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
+    public TimeSpan IntervalSeconds { get; set; }
+}

BTCPayServer.Client/Models/LightningNodeBalanceData.cs

@@ -0,0 +1,52 @@
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.Lightning;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class LightningNodeBalanceData
+    {
+        [JsonProperty("onchain")]
+        public OnchainBalanceData OnchainBalance { get; set; }
+        
+        [JsonProperty("offchain")]
+        public OffchainBalanceData OffchainBalance { get; set; }
+        
+        public LightningNodeBalanceData()
+        {
+        }
+
+        public LightningNodeBalanceData(OnchainBalanceData onchain, OffchainBalanceData offchain)
+        {
+            OnchainBalance = onchain;
+            OffchainBalance = offchain;
+        }
+    }
+
+    public class OnchainBalanceData
+    {
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Confirmed { get; set; }
+        
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Unconfirmed { get; set; }
+        
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Reserved { get; set; }
+    }
+
+    public class OffchainBalanceData
+    {
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Opening { get; set; }
+        
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Local { get; set; }
+        
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Remote { get; set; }
+        
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Closing { get; set; }
+    }
+}

BTCPayServer.Client/Models/LightningPaymentData.cs

@@ -0,0 +1,32 @@
+using System;
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.Lightning;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models
+{
+    public class LightningPaymentData
+    {
+        public string Id { get; set; }
+
+        public string PaymentHash { get; set; }
+
+        [JsonConverter(typeof(StringEnumConverter))]
+        public LightningPaymentStatus Status { get; set; }
+
+        [JsonProperty("BOLT11")]
+        public string BOLT11 { get; set; }
+        
+        public string Preimage { get; set; }
+
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? CreatedAt { get; set; }
+        
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney TotalAmount { get; set; }
+
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney FeeAmount { get; set; }
+    }
+}

BTCPayServer.Client/Models/LockUserRequest.cs

@@ -0,0 +1,6 @@
+namespace BTCPayServer.Client;
+
+public class LockUserRequest
+{
+    public bool Locked { get; set; }
+}

BTCPayServer.Client/Models/MarketTradeResponseData.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models;
+
+public class MarketTradeResponseData
+{
+    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 string AccountId { get; }
+    
+    public string CustodianCode { get; }
+
+    public MarketTradeResponseData(string fromAsset, string toAsset, List<LedgerEntryData> ledgerEntries, string tradeId, string accountId, string custodianCode)
+    {
+        FromAsset = fromAsset;
+        ToAsset = toAsset;
+        LedgerEntries = ledgerEntries;
+        TradeId = tradeId;
+        AccountId = accountId;
+        CustodianCode = custodianCode;
+    }
+}

BTCPayServer.Client/Models/OnChainAutomatedPayoutSettings.cs

@@ -0,0 +1,13 @@
+using System;
+using BTCPayServer.Client.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class OnChainAutomatedPayoutSettings
+{
+    public string PaymentMethod { get; set; }
+       
+    [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
+    public TimeSpan IntervalSeconds { get; set; }
+}

BTCPayServer.Client/Models/OnChainWalletTransactionData.cs

@@ -21,9 +21,9 @@ namespace BTCPayServer.Client.Models
         [JsonConverter(typeof(UInt256JsonConverter))]
         public uint256 BlockHash { get; set; }
 
-        public int? BlockHeight { get; set; }
+        public long? BlockHeight { get; set; }
 
-        public int Confirmations { get; set; }
+        public long Confirmations { get; set; }
 
         [JsonConverter(typeof(DateTimeToUnixTimeConverter))]
         public DateTimeOffset Timestamp { get; set; }

BTCPayServer.Client/Models/OnChainWalletUTXOData.cs

@@ -21,6 +21,6 @@ namespace BTCPayServer.Client.Models
         [JsonConverter(typeof(KeyPathJsonConverter))]
         public KeyPath KeyPath { get; set; }
         public string Address { get; set; }
-        public int Confirmations { get; set; }
+        public long Confirmations { get; set; }
     }
 }

BTCPayServer.Client/Models/PatchOnChainTransactionRequest.cs

@@ -0,0 +1,12 @@
+#nullable enable
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models
+{
+    public class PatchOnChainTransactionRequest
+    {
+
+        public string? Comment { get; set; } = null;
+        public List<string>? Labels { get; set; } = null;
+    }
+}

BTCPayServer.Client/Models/PayLightningInvoiceRequest.cs

@@ -1,8 +1,23 @@
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.JsonConverters;
+using BTCPayServer.Lightning;
+using NBitcoin;
+using Newtonsoft.Json;
+
 namespace BTCPayServer.Client.Models
 {
     public class PayLightningInvoiceRequest
     {
-        [Newtonsoft.Json.JsonProperty("BOLT11")]
+        [JsonProperty("BOLT11")]
         public string BOLT11 { get; set; }
+        
+        [JsonProperty(ItemConverterType = typeof(NumericStringJsonConverter))]
+        public float? MaxFeePercent { get; set; }
+        
+        [JsonConverter(typeof(MoneyJsonConverter))]
+        public Money MaxFeeFlat { get; set; }
+    
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Amount { get; set; }
     }
 }

BTCPayServer.Client/Models/PayoutProcessorData.cs

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Client.Models
+{
+    public class PayoutProcessorData
+    {
+        public string Name { get; set; }
+        public string FriendlyName { get; set; }
+        public string[] PaymentMethods { get; set; }
+    }
+}

BTCPayServer.Client/Models/PointOfSaleAppData.cs

@@ -0,0 +1,20 @@
+using System;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class AppDataBase
+    {
+        public string Id { get; set; }
+        public string AppType { get; set; }
+        public string Name { get; set; }
+        public string StoreId { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset Created { get; set; }
+    }
+    
+    public class PointOfSaleAppData : AppDataBase
+    {
+        // We can add POS specific things here later
+    }
+}

BTCPayServer.Client/Models/PullPaymentBaseData.cs

@@ -5,6 +5,13 @@ using Newtonsoft.Json;
 
 namespace BTCPayServer.Client.Models
 {
+    public enum PullPaymentState
+    {
+        Active,
+        Expired,
+        Archived,
+        Future
+    }
     public class PullPaymentData
     {
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
@@ -24,5 +31,6 @@ namespace BTCPayServer.Client.Models
         public TimeSpan BOLT11Expiration { get; set; }
         public bool Archived { get; set; }
         public string ViewLink { get; set; }
+        public bool AutoApproveClaims { get; set; }
     }
 }

BTCPayServer.Client/Models/SendEmailRequest.cs

@@ -0,0 +1,10 @@
+
+namespace BTCPayServer.Client.Models
+{
+    public class SendEmailRequest
+    {
+        public string Email;
+        public string Subject;
+        public string Body;
+    }
+}

BTCPayServer.Client/Models/StoreBaseData.cs

@@ -58,6 +58,8 @@ namespace BTCPayServer.Client.Models
         public NetworkFeeMode NetworkFeeMode { get; set; } = NetworkFeeMode.Never;
 
         public bool PayJoinEnabled { get; set; }
+        
+        public InvoiceData.ReceiptOptions Receipt { get; set; }
 
 
         [JsonExtensionData]

BTCPayServer.Client/Models/TradeQuoteResponseData.cs

@@ -0,0 +1,17 @@
+namespace BTCPayServer.Client.Models;
+
+public class TradeQuoteResponseData
+{
+    public decimal Bid { get; }
+    public decimal Ask { get; }
+    public string ToAsset { get; }
+    public string FromAsset { get; }
+
+    public TradeQuoteResponseData(string fromAsset, string toAsset, decimal bid, decimal ask)
+    {
+        FromAsset = fromAsset;
+        ToAsset = toAsset;
+        Bid = bid;
+        Ask = ask;
+    }
+}

BTCPayServer.Client/Models/TradeRequestData.cs

@@ -0,0 +1,8 @@
+namespace BTCPayServer.Client.Models;
+
+public class TradeRequestData
+{
+    public string FromAsset { set; get; }
+    public string ToAsset { set; get; }
+    public string Qty { set; get; }
+}

BTCPayServer.Client/Models/TransactionStatus.cs

@@ -3,7 +3,6 @@ namespace BTCPayServer.Client.Models
     public enum TransactionStatus
     {
         Unconfirmed,
-        Confirmed,
-        Replaced
+        Confirmed
     }
 }

BTCPayServer.Client/Models/WebhookEventType.cs

@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
 namespace BTCPayServer.Client.Models
 {
     public enum WebhookEventType

BTCPayServer.Client/Models/WithdrawRequestData.cs

@@ -0,0 +1,13 @@
+namespace BTCPayServer.Client.Models;
+
+public class WithdrawRequestData
+{
+    public string PaymentMethod { set; get; }
+    public decimal Qty { set; get; }
+
+    public WithdrawRequestData(string paymentMethod, decimal qty)
+    {
+        PaymentMethod = paymentMethod;
+        Qty = qty;
+    }
+}

BTCPayServer.Client/Models/WithdrawalResponseData.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models;
+
+public class WithdrawalResponseData
+{
+    public string Asset { get; }
+    public string PaymentMethod { get; }
+    public List<LedgerEntryData> LedgerEntries { get; }
+    public string WithdrawalId { get; }
+    public string AccountId { get; }
+    public string CustodianCode { get; }
+
+    [JsonConverter(typeof(StringEnumConverter))]
+    public WithdrawalStatus Status { get; }
+
+    public DateTimeOffset CreatedTime { get; }
+
+    public string TransactionId { get; }
+
+    public string TargetAddress { get; }
+
+    public WithdrawalResponseData(string paymentMethod, string asset, List<LedgerEntryData> ledgerEntries, string withdrawalId, string accountId,
+        string custodianCode, WithdrawalStatus status, DateTimeOffset createdTime, string targetAddress, string transactionId)
+    {
+        PaymentMethod = paymentMethod;
+        Asset = asset;
+        LedgerEntries = ledgerEntries;
+        WithdrawalId = withdrawalId;
+        AccountId = accountId;
+        CustodianCode = custodianCode;
+        TargetAddress = targetAddress;
+        TransactionId = transactionId;
+        Status = status;
+        CreatedTime = createdTime;
+    }
+
+
+    public enum WithdrawalStatus
+    {
+        Unknown = 0,
+        Queued = 1,
+        Complete = 2,
+        Failed = 3
+    }
+}