Bump tests to Bitcoin Core 24.1

.circleci/config.yml

@@ -31,23 +31,79 @@ jobs:
       - 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"}'
+
   # publish jobs require $DOCKERHUB_REPO, $DOCKERHUB_USER, $DOCKERHUB_PASS defined
-  docker:
-    docker:
-      - image: cimg/base:stable
+  amd64:
+    machine:
+      image: ubuntu-2004:202111-02
     steps:
-      - setup_remote_docker
       - checkout
       - run:
           command: |
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
             GIT_COMMIT=$(git rev-parse HEAD)
             #
-            docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
-            docker buildx create --use
-            DOCKER_BUILDX_OPTS="--platform linux/amd64,linux/arm64,linux/arm/v7 --build-arg GIT_COMMIT=${GIT_COMMIT} --push"
-            docker buildx build $DOCKER_BUILDX_OPTS -t $DOCKERHUB_REPO:$LATEST_TAG .
-            docker buildx build $DOCKER_BUILDX_OPTS -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins --build-arg CONFIGURATION_NAME=Altcoins-Release .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f amd64.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 -f amd64.Dockerfile .
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-amd64
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64
+
+  arm32v7:
+    machine:
+      image: ubuntu-2004:202111-02
+    steps:
+      - checkout
+      - run:
+          command: |
+            sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            GIT_COMMIT=$(git rev-parse HEAD)
+            #
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f arm32v7.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 -f arm32v7.Dockerfile .
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7
+
+  arm64v8:
+    machine:
+      image: ubuntu-2004:202111-02
+    steps:
+      - checkout
+      - run:
+          command: |
+            sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            GIT_COMMIT=$(git rev-parse HEAD)
+            #
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 -f arm64v8.Dockerfile .
+            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --build-arg CONFIGURATION_NAME=Altcoins-Release --pull -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8 -f arm64v8.Dockerfile .
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm64v8
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8
+
+  multiarch:
+    machine:
+      image: ubuntu-2004:202201-02
+    steps:
+      - run:
+          command: |
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            #
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            sudo docker manifest create --amend $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-amd64 $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 $DOCKERHUB_REPO:$LATEST_TAG-arm64v8
+            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-amd64 --os linux --arch amd64
+            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
+            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8 --os linux --arch arm64 --variant v8
+            sudo docker manifest push $DOCKERHUB_REPO:$LATEST_TAG-altcoins -p
+
 workflows:
   version: 2
   build_and_test:
@@ -64,7 +120,7 @@ workflows:
             # only act on version tags
             tags:
               only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
-      - docker:
+      - amd64:
           filters:
             # ignore any commit on any branch by default
             branches:
@@ -74,3 +130,25 @@ workflows:
             # OR features on specific versions like v1.0.0.88-lndseedbackup-1
             tags:
               only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
+      - arm32v7:
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
+      - arm64v8:
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
+      - multiarch:
+          requires:
+            - amd64
+            - arm32v7
+            - arm64v8
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/

.github/codeql/codeql-config.yml

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

.github/workflows/codeql.yml

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

.gitignore

@@ -298,6 +298,4 @@ Packed Plugins
 Plugins/packed
 
 BTCPayServer/wwwroot/swagger/v1/openapi.json
-BTCPayServer/appsettings.dev.json
-BTCPayServer.Tests/monero_wallet
-/BTCPayServer.Tests/NewBlocks.bat
+BTCPayServer/appsettings.dev.json

.vscode/launch.json

@@ -10,7 +10,7 @@
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/BTCPayServer/bin/Debug/net8.0/BTCPayServer.dll",
+            "program": "${workspaceFolder}/BTCPayServer/bin/Debug/net6.0/BTCPayServer.dll",
             "args": [],
             "cwd": "${workspaceFolder}/BTCPayServer",
             "stopAtEntry": false,

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

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

BTCPayServer.Abstractions/Contracts/BaseDbContextFactory.cs

@@ -21,6 +21,7 @@ namespace BTCPayServer.Abstractions.Contracts
         }
 
         public abstract T CreateContext();
+
         class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
         {
 #pragma warning disable EF1001 // Internal EF Core API usage.
@@ -83,7 +84,6 @@ namespace BTCPayServer.Abstractions.Contracts
                         .UseNpgsql(_options.Value.ConnectionString, o =>
                         {
                             o.EnableRetryOnFailure(10);
-                            o.SetPostgresVersion(12, 0);
                             if (!string.IsNullOrEmpty(_schemaPrefix))
                             {
                                 o.MigrationsHistoryTable(_schemaPrefix);

BTCPayServer.Abstractions/Contracts/IPluginHookService.cs

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

BTCPayServer.Abstractions/Custodians/Client/AssetQuoteResult.cs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

BTCPayServer.Abstractions/Custodians/Client/MarketTradeResult.cs

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

BTCPayServer.Abstractions/Custodians/Client/SimulateWithdrawalResult.cs

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

BTCPayServer.Abstractions/Custodians/Client/WithdrawResult.cs

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

BTCPayServer.Abstractions/Custodians/ICanDeposit.cs

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

BTCPayServer.Abstractions/Custodians/ICanTrade.cs

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

BTCPayServer.Abstractions/Custodians/ICanWithdraw.cs

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

BTCPayServer.Abstractions/Custodians/ICustodian.cs

@@ -0,0 +1,26 @@
+#nullable enable
+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, 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/ViewsRazor.cs

@@ -20,15 +20,6 @@ namespace BTCPayServer.Abstractions.Extensions
             Relative
         }
 
-        public static void SetBlazorAllowed(this ViewDataDictionary viewData, bool allowed)
-        {
-            viewData["BlazorAllowed"] = allowed;
-        }
-        public static bool IsBlazorAllowed(this ViewDataDictionary viewData)
-        {
-            return viewData["BlazorAllowed"] is not false;
-        }
-
         public static void SetActivePage<T>(this ViewDataDictionary viewData, T activePage, string title = null, string activeId = null)
             where T : IConvertible
         {
@@ -101,14 +92,6 @@ namespace BTCPayServer.Abstractions.Extensions
             return categoryAndPageMatch && idMatch ? ActivePageClass : null;
         }
 
-        public static HtmlString ToBrowserDate(this DateTimeOffset date, string netFormat, string jsDateFormat = "short", string jsTimeFormat = "short")
-        {
-            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
-            var displayDate = date.ToString(netFormat, CultureInfo.InvariantCulture);
-            var tooltip = dateTime.Replace("T", " ");
-            return new HtmlString($"<time datetime=\"{dateTime}\" data-date-style=\"{jsDateFormat}\" data-time-style=\"{jsTimeFormat}\" data-initial=\"localized\" data-bs-toggle=\"tooltip\" data-bs-title=\"{tooltip}\">{displayDate}</time>");
-        }
-
         public static HtmlString ToBrowserDate(this DateTimeOffset date, DateDisplayFormat format = DateDisplayFormat.Localized)
         {
             var relative = date.ToTimeAgo();

BTCPayServer.Abstractions/Form/Form.cs

@@ -5,6 +5,7 @@ using System.Reflection;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
 using Newtonsoft.Json.Linq;
+using Npgsql.Internal.TypeHandlers.GeometricHandlers;
 
 namespace BTCPayServer.Abstractions.Form;
 
@@ -68,6 +69,7 @@ public class Form
             if (!nameReturned.Add(fullName))
             {
                 errors.Add($"Form contains duplicate field names '{fullName}'");
+                continue;
             }
         }
         return errors.Count == 0;
@@ -84,10 +86,15 @@ public class Form
                 thisPath.Add(field.Name);
                 yield return (thisPath, field);
             }
-            foreach (var descendant in GetAllFieldsCore(thisPath, field.Fields))
+
+            foreach (var child in field.Fields)
             {
-                descendant.Field.Constant = field.Constant || descendant.Field.Constant;
-                yield return descendant;
+                if (field.Constant)
+                    child.Constant = true;
+                foreach (var descendant in GetAllFieldsCore(thisPath, field.Fields))
+                {
+                    yield return descendant;
+                }
             }
         }
     }
@@ -104,7 +111,31 @@ public class Form
         }
     }
 
-    
+    public void SetValues(JObject values)
+    {
+        var fields = GetAllFields().ToDictionary(k => k.FullName, k => k.Field);
+        SetValues(fields, new List<string>(), values);
+    }
+
+    private void SetValues(Dictionary<string, Field> fields, List<string> path, JObject values)
+    {
+        foreach (var prop in values.Properties())
+        {
+            List<string> propPath = new List<string>(path.Count + 1);
+            propPath.AddRange(path);
+            propPath.Add(prop.Name);
+            if (prop.Value.Type == JTokenType.Object)
+            {
+                SetValues(fields, propPath, (JObject)prop.Value);
+            }
+            else if (prop.Value.Type == JTokenType.String)
+            {
+                var fullName = string.Join('_', propPath.Where(s => !string.IsNullOrEmpty(s)));
+                if (fields.TryGetValue(fullName, out var f) && !f.Constant)
+                    f.Value = prop.Value.Value<string>();
+            }
+        }
+    }
 
 
 }

BTCPayServer.Abstractions/Services/Safe.cs

@@ -1,5 +1,4 @@
-using System.Web;
-using Ganss.Xss;
+using Ganss.XSS;
 using Microsoft.AspNetCore.Html;
 using Microsoft.AspNetCore.Mvc.Rendering;
 
@@ -22,11 +21,6 @@ namespace BTCPayServer.Abstractions.Services
         {
             return _htmlHelper.Raw(_htmlSanitizer.Sanitize(value));
         }
-        
-        public IHtmlContent RawEncode(string value)
-        {
-            return _htmlHelper.Raw(HttpUtility.HtmlEncode(_htmlSanitizer.Sanitize(value)));
-        }
 
         public IHtmlContent Json(object model)
         {

BTCPayServer.Abstractions/TagHelpers/PermissionTagHelper.cs

@@ -2,93 +2,47 @@ using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Razor.TagHelpers;
-using System;
-using System.Linq;
+using Microsoft.Extensions.Logging;
 
 namespace BTCPayServer.Abstractions.TagHelpers;
 
-[HtmlTargetElement(Attributes = "[permission]")]
-[HtmlTargetElement(Attributes = "[not-permission]")]
+[HtmlTargetElement(Attributes = nameof(Permission))]
 public class PermissionTagHelper : TagHelper
 {
     private readonly IAuthorizationService _authorizationService;
     private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly ILogger<PermissionTagHelper> _logger;
 
-    public PermissionTagHelper(IAuthorizationService authorizationService, IHttpContextAccessor httpContextAccessor)
+    public PermissionTagHelper(IAuthorizationService authorizationService, IHttpContextAccessor httpContextAccessor, ILogger<PermissionTagHelper> logger)
     {
         _authorizationService = authorizationService;
         _httpContextAccessor = httpContextAccessor;
+        _logger = logger;
     }
 
     public string Permission { get; set; }
-    public string NotPermission { get; set; }
     public string PermissionResource { get; set; }
-    public bool AndMode { get; set; } = false;
 
     public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
     {
-        var permissions = Permission?.Split(',', StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
-        var notPermissions = NotPermission?.Split(',', StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
-
-        if (!permissions.Any() && !notPermissions.Any())
+        if (string.IsNullOrEmpty(Permission))
             return;
         if (_httpContextAccessor.HttpContext is null)
             return;
 
-        bool shouldRender = true; // Assume tag should be rendered unless a check fails
-
-        // Process 'Permission' - User must have these permissions
-        if (permissions.Any())
+        var key = $"{Permission}_{PermissionResource}";
+        if (!_httpContextAccessor.HttpContext.Items.TryGetValue(key, out var o) ||
+            o is not AuthorizationResult res)
         {
-            bool finalResult = AndMode;
-            foreach (var perm in permissions)
-            {
-                var key = $"{perm}_{PermissionResource}";
-                AuthorizationResult res = await GetOrAddAuthorizationResult(key, perm);
-
-                if (AndMode)
-                    finalResult &= res.Succeeded;
-                else
-                    finalResult |= res.Succeeded;
-
-                if (!AndMode && finalResult) break;
-            }
-
-            shouldRender = finalResult;
+            res = await _authorizationService.AuthorizeAsync(_httpContextAccessor.HttpContext.User,
+                PermissionResource,
+                Permission);
+            _httpContextAccessor.HttpContext.Items.Add(key, res);
         }
-
-        // Process 'NotPermission' - User must not have these permissions
-        if (shouldRender && notPermissions.Any())
-        {
-            foreach (var notPerm in notPermissions)
-            {
-                var key = $"{notPerm}_{PermissionResource}";
-                AuthorizationResult res = await GetOrAddAuthorizationResult(key, notPerm);
-
-                if (res.Succeeded) // If the user has a 'NotPermission', they should not see the tag
-                {
-                    shouldRender = false;
-                    break;
-                }
-            }
-        }
-
-        if (!shouldRender)
+        if (!res.Succeeded)
         {
             output.SuppressOutput();
         }
-    }
 
-    private async Task<AuthorizationResult> GetOrAddAuthorizationResult(string key, string permission)
-    {
-        if (!_httpContextAccessor.HttpContext.Items.TryGetValue(key, out var cachedResult))
-        {
-            var res = await _authorizationService.AuthorizeAsync(_httpContextAccessor.HttpContext.User,
-                PermissionResource, permission);
-            _httpContextAccessor.HttpContext.Items[key] = res;
-            return res;
-        }
-
-        return cachedResult as AuthorizationResult;
     }
 }

BTCPayServer.Abstractions/TagHelpers/PermissionedFormTagHelper.cs

@@ -1,35 +0,0 @@
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Razor.TagHelpers;
-
-namespace BTCPayServer.Abstractions.TagHelpers;
-
-[HtmlTargetElement("form", Attributes = "[permissioned]")]
-public partial class PermissionedFormTagHelper(
-    IAuthorizationService authorizationService,
-    IHttpContextAccessor httpContextAccessor)
-    : TagHelper
-{
-    public string Permissioned { get; set; }
-    public string PermissionResource { get; set; }
-
-    public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
-    {
-        if (httpContextAccessor.HttpContext is null || string.IsNullOrEmpty(Permissioned))
-            return;
-
-        var res = await authorizationService.AuthorizeAsync(httpContextAccessor.HttpContext.User,
-            PermissionResource, Permissioned);
-        if (!res.Succeeded)
-        {
-            var content = await output.GetChildContentAsync();
-            var html = SubmitButtonRegex().Replace(content.GetContent(), "");
-            output.Content.SetHtmlContent($"<fieldset disabled>{html}</fieldset>");
-        }
-    }
-
-    [GeneratedRegex("<(button|input).*?type=\"submit\".*?>.*?</\\1>")]
-    private static partial Regex SubmitButtonRegex();
-}

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -12,11 +12,9 @@
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <RepositoryUrl>https://github.com/btcpayserver/btcpayserver</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
-        <Configurations>Debug;Release;Altcoins-Debug;Altcoins-Release</Configurations>
-        <Platforms>AnyCPU</Platforms>
     </PropertyGroup>
   <PropertyGroup>
-    <Version Condition=" '$(Version)' == '' ">1.7.4</Version>
+    <Version Condition=" '$(Version)' == '' ">1.7.2</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -30,9 +28,9 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.5.1" />
-      <PackageReference Include="NBitcoin" Version="7.0.34" />
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.3.21" />
+      <PackageReference Include="NBitcoin" Version="7.0.24" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     </ItemGroup>
   <ItemGroup>
     <None Include="icon.png" Pack="true" PackagePath="\" />

BTCPayServer.Client/BTCPayServerClient.CustodianAccounts.cs

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

BTCPayServer.Client/BTCPayServerClient.Custodians.cs

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

BTCPayServer.Client/BTCPayServerClient.LNURLPayPaymentMethods.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<IEnumerable<LNURLPayPaymentMethodData>>
+            GetStoreLNURLPayPaymentMethods(string storeId, bool? enabled = null,
+                CancellationToken token = default)
+        {
+            var query = new Dictionary<string, object>();
+            if (enabled != null)
+            {
+                query.Add(nameof(enabled), enabled);
+            }
+
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay",
+                        query), token);
+            return await HandleResponse<IEnumerable<LNURLPayPaymentMethodData>>(response);
+        }
+
+        public virtual async Task<LNURLPayPaymentMethodData> GetStoreLNURLPayPaymentMethod(
+            string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}"), token);
+            return await HandleResponse<LNURLPayPaymentMethodData>(response);
+        }
+
+        public virtual async Task RemoveStoreLNURLPayPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}",
+                        method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<LNURLPayPaymentMethodData> UpdateStoreLNURLPayPaymentMethod(
+            string storeId,
+            string cryptoCode, LNURLPayPaymentMethodData paymentMethod,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}",
+                    bodyPayload: paymentMethod, method: HttpMethod.Put), token);
+            return await HandleResponse<LNURLPayPaymentMethodData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.LightningNetworkPaymentMethods.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<IEnumerable<LightningNetworkPaymentMethodData>>
+            GetStoreLightningNetworkPaymentMethods(string storeId, bool? enabled = null,
+                CancellationToken token = default)
+        {
+            var query = new Dictionary<string, object>();
+            if (enabled != null)
+            {
+                query.Add(nameof(enabled), enabled);
+            }
+
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork",
+                        query), token);
+            return await HandleResponse<IEnumerable<LightningNetworkPaymentMethodData>>(response);
+        }
+
+        public virtual async Task<LightningNetworkPaymentMethodData> GetStoreLightningNetworkPaymentMethod(
+            string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork/{cryptoCode}"), token);
+            return await HandleResponse<LightningNetworkPaymentMethodData>(response);
+        }
+
+        public virtual async Task RemoveStoreLightningNetworkPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork/{cryptoCode}",
+                        method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<LightningNetworkPaymentMethodData> UpdateStoreLightningNetworkPaymentMethod(
+            string storeId,
+            string cryptoCode, UpdateLightningNetworkPaymentMethodRequest paymentMethod,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork/{cryptoCode}",
+                    bodyPayload: paymentMethod, method: HttpMethod.Put), token);
+            return await HandleResponse<LightningNetworkPaymentMethodData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.OnChainPaymentMethods.cs

@@ -3,47 +3,92 @@ using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
-using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client
 {
-	public partial class BTCPayServerClient
-	{
-		public virtual async Task<OnChainPaymentMethodPreviewResultData>
-			PreviewProposedStoreOnChainPaymentMethodAddresses(
-				string storeId, string paymentMethodId, string derivationScheme, int offset = 0,
-				int amount = 10,
-				CancellationToken token = default)
-		{
-			var response = await _httpClient.SendAsync(
-				CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/preview",
-					bodyPayload: new UpdatePaymentMethodRequest() { Config = JValue.CreateString(derivationScheme) },
-					queryPayload: new Dictionary<string, object>() { { "offset", offset }, { "amount", amount } },
-					method: HttpMethod.Post), token);
-			return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
-		}
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<IEnumerable<OnChainPaymentMethodData>> GetStoreOnChainPaymentMethods(string storeId,
+            bool? enabled = null,
+            CancellationToken token = default)
+        {
+            var query = new Dictionary<string, object>();
+            if (enabled != null)
+            {
+                query.Add(nameof(enabled), enabled);
+            }
 
-		public virtual async Task<OnChainPaymentMethodPreviewResultData> PreviewStoreOnChainPaymentMethodAddresses(
-			string storeId, string paymentMethodId, int offset = 0, int amount = 10,
-			CancellationToken token = default)
-		{
-			var response = await _httpClient.SendAsync(
-				CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/preview",
-					queryPayload: new Dictionary<string, object>() { { "offset", offset }, { "amount", amount } },
-					method: HttpMethod.Get), token);
-			return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
-		}
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain",
+                        query), token);
+            return await HandleResponse<IEnumerable<OnChainPaymentMethodData>>(response);
+        }
 
-		public virtual async Task<GenerateOnChainWalletResponse> GenerateOnChainWallet(string storeId,
-			string paymentMethodId, GenerateOnChainWalletRequest request,
-			CancellationToken token = default)
-		{
-			var response = await _httpClient.SendAsync(
-				CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/generate",
-					bodyPayload: request,
-					method: HttpMethod.Post), token);
-			return await HandleResponse<GenerateOnChainWalletResponse>(response);
-		}
+        public virtual async Task<OnChainPaymentMethodData> GetStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}"), token);
+            return await HandleResponse<OnChainPaymentMethodData>(response);
+        }
 
-	}
+        public virtual async Task RemoveStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}",
+                        method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodData> UpdateStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, UpdateOnChainPaymentMethodRequest paymentMethod,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}",
+                    bodyPayload: paymentMethod, method: HttpMethod.Put), token);
+            return await HandleResponse<OnChainPaymentMethodData>(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodPreviewResultData>
+            PreviewProposedStoreOnChainPaymentMethodAddresses(
+                string storeId, string cryptoCode, UpdateOnChainPaymentMethodRequest paymentMethod, int offset = 0,
+                int amount = 10,
+                CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/preview",
+                    bodyPayload: paymentMethod,
+                    queryPayload: new Dictionary<string, object>() { { "offset", offset }, { "amount", amount } },
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodPreviewResultData> PreviewStoreOnChainPaymentMethodAddresses(
+            string storeId, string cryptoCode, int offset = 0, int amount = 10,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/preview",
+                    queryPayload: new Dictionary<string, object>() { { "offset", offset }, { "amount", amount } },
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodDataWithSensitiveData> GenerateOnChainWallet(string storeId,
+            string cryptoCode, GenerateOnChainWalletRequest request,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/generate",
+                    bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<OnChainPaymentMethodDataWithSensitiveData>(response);
+        }
+
+    }
 }

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.cs

@@ -55,7 +55,7 @@ namespace BTCPayServer.Client
         }
 
         public virtual async Task<IEnumerable<OnChainWalletTransactionData>> ShowOnChainWalletTransactions(
-            string storeId, string cryptoCode, TransactionStatus[] statusFilter = null, string labelFilter = null, int skip = 0,
+            string storeId, string cryptoCode, TransactionStatus[] statusFilter = null, string labelFilter = null,
             CancellationToken token = default)
         {
             var query = new Dictionary<string, object>();
@@ -67,10 +67,6 @@ namespace BTCPayServer.Client
             {
                 query.Add(nameof(labelFilter), labelFilter);
             }
-            if (skip != 0)
-            {
-                query.Add(nameof(skip), skip);
-            }
             var response =
                 await _httpClient.SendAsync(
                     CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", query), token);

BTCPayServer.Client/BTCPayServerClient.PullPayments.cs

@@ -20,12 +20,6 @@ namespace BTCPayServer.Client
             return await HandleResponse<PullPaymentData>(response);
         }
 
-        public virtual async Task<RegisterBoltcardResponse> RegisterBoltcard(string pullPaymentId, RegisterBoltcardRequest request, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/boltcards", bodyPayload: request, method: HttpMethod.Post), cancellationToken);
-            return await HandleResponse<RegisterBoltcardResponse>(response);
-        }
-
         public virtual async Task<PullPaymentData[]> GetPullPayments(string storeId, bool includeArchived = false, CancellationToken cancellationToken = default)
         {
             Dictionary<string, object> query = new Dictionary<string, object>();

BTCPayServer.Client/BTCPayServerClient.ServerInfo.cs

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

BTCPayServer.Client/BTCPayServerClient.StorePaymentMethods.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
@@ -8,60 +7,21 @@ namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public virtual async Task<GenericPaymentMethodData> UpdateStorePaymentMethod(
-            string storeId,
-            string paymentMethodId,
-            UpdatePaymentMethodRequest request,
+        public virtual async Task<Dictionary<string, GenericPaymentMethodData>> GetStorePaymentMethods(string storeId,
+            bool? enabled = null,
             CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}", bodyPayload: request, method: HttpMethod.Put),
-                    token);
-            return await HandleResponse<GenericPaymentMethodData>(response);
-        }
-        public virtual async Task RemoveStorePaymentMethod(string storeId, string paymentMethodId)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}", method: HttpMethod.Delete),
-                    CancellationToken.None);
-            await HandleResponse(response);
-        }
-
-        public virtual async Task<GenericPaymentMethodData> GetStorePaymentMethod(string storeId,
-            string paymentMethodId, bool? includeConfig = null, CancellationToken token = default)
         {
             var query = new Dictionary<string, object>();
-            if (includeConfig != null)
+            if (enabled != null)
             {
-                query.Add(nameof(includeConfig), includeConfig);
-            }
-
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}",
-                        query), token);
-            return await HandleResponse<GenericPaymentMethodData>(response);
-        }
-        public virtual async Task<GenericPaymentMethodData[]> GetStorePaymentMethods(string storeId,
-            bool? onlyEnabled = null, bool? includeConfig = null, CancellationToken token = default)
-        {
-            var query = new Dictionary<string, object>();
-            if (onlyEnabled != null)
-            {
-                query.Add(nameof(onlyEnabled), onlyEnabled);
-            }
-            if (includeConfig != null)
-            {
-                query.Add(nameof(includeConfig), includeConfig);
+                query.Add(nameof(enabled), enabled);
             }
 
             var response =
                 await _httpClient.SendAsync(
                     CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods",
                         query), token);
-            return await HandleResponse<GenericPaymentMethodData[]>(response);
+            return await HandleResponse<Dictionary<string, GenericPaymentMethodData>>(response);
         }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

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

BTCPayServer.Client/BTCPayServerClient.Users.cs

@@ -41,14 +41,6 @@ namespace BTCPayServer.Client
             return response.IsSuccessStatusCode;
         }
 
-        public virtual async Task<bool> ApproveUser(string idOrEmail, bool approved, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}/approve", null,
-                new ApproveUserRequest { Approved = approved }, HttpMethod.Post), token);
-            await HandleResponse(response);
-            return response.IsSuccessStatusCode;
-        }
-
         public virtual async Task<ApplicationUserData[]> GetUsers(CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/", null, HttpMethod.Get), token);

BTCPayServer.Client/BTCPayServerClient.cs

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

BTCPayServer.Client/JsonConverters/SaneOutpointJsonConverter.cs

@@ -1,43 +0,0 @@
-using NBitcoin;
-using NBitcoin.DataEncoders;
-using NBitcoin.JsonConverters;
-using Newtonsoft.Json;
-using System;
-using System.IO;
-using System.Reflection;
-
-namespace BTCPayServer.Client.JsonConverters
-{
-    public class SaneOutpointJsonConverter : JsonConverter
-    {
-        public override bool CanConvert(Type objectType)
-        {
-            return typeof(OutPoint).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo());
-        }
-
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-        {
-            if (reader.TokenType == JsonToken.Null)
-                return null;
-
-            if (reader.TokenType != JsonToken.String)
-                throw new JsonObjectException($"Unexpected json token type, expected is {JsonToken.String} and actual is {reader.TokenType}", reader);
-            try
-            {
-                if (!OutPoint.TryParse((string)reader.Value, out var outpoint))
-                    throw new JsonObjectException("Invalid bitcoin object of type OutPoint", reader);
-                return outpoint;
-            }
-            catch (EndOfStreamException)
-            {
-            }
-            throw new JsonObjectException("Invalid bitcoin object of type OutPoint", reader);
-        }
-
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-        {
-            if (value is { })
-                writer.WriteValue(value.ToString());
-        }
-    }
-}

BTCPayServer.Client/JsonConverters/TradeQuantityJsonConverter.cs

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

BTCPayServer.Client/Models/ApplicationUserData.cs

@@ -25,16 +25,6 @@ namespace BTCPayServer.Client.Models
         /// </summary>
         public bool RequiresEmailConfirmation { get; set; }
 
-        /// <summary>
-        /// Whether the user was approved by an admin
-        /// </summary>
-        public bool Approved { get; set; }
-
-        /// <summary>
-        /// whether the user needed approval on account creation
-        /// </summary>
-        public bool RequiresApproval { get; set; }
-
         /// <summary>
         /// the roles of the user
         /// </summary>

BTCPayServer.Client/Models/ApproveUserRequest.cs

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

BTCPayServer.Client/Models/CreateAppRequest.cs

@@ -26,12 +26,9 @@ namespace BTCPayServer.Client.Models
         public string Template { get; set; } = null;
         [JsonConverter(typeof(StringEnumConverter))]
         public PosViewType DefaultView { get; set; }
-        public bool ShowItems { get; set; } = false;
         public bool ShowCustomAmount { get; set; } = false;
-        public bool ShowDiscount { get; set; } = false;
-        public bool ShowSearch { get; set; } = true;
-        public bool ShowCategories { get; set; } = true;
-        public bool EnableTips { get; set; } = false;
+        public bool ShowDiscount { get; set; } = true;
+        public bool EnableTips { get; set; } = true;
         public string CustomAmountPayButtonText { get; set; } = null;
         public string FixedAmountPayButtonText { get; set; } = null;
         public string TipText { get; set; } = null;
@@ -40,9 +37,9 @@ namespace BTCPayServer.Client.Models
         public string RedirectUrl { get; set; } = null;
         public bool? RedirectAutomatically { get; set; } = null;
         public bool? RequiresRefundEmail { get; set; } = null;
-        public bool? Archived { get; set; } = null;
         public string FormId { get; set; } = null;
         public string EmbeddedCSS { get; set; } = null;
+        public CheckoutType? CheckoutType { get; set; } = null;
     }
 
     public enum CrowdfundResetEvery
@@ -81,7 +78,6 @@ namespace BTCPayServer.Client.Models
         public bool? DisplayPerksValue { get; set; } = null;
         public bool? DisplayPerksRanking { get; set; } = null;
         public bool? SortPerksByPopularity { get; set; } = null;
-        public bool? Archived { get; set; } = null;
         public string[] Sounds { get; set; } = null;
         public string[] AnimationColors { get; set; } = null;
     }

BTCPayServer.Client/Models/CreateCustodianAccountRequest.cs

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

BTCPayServer.Client/Models/CreateOnChainTransactionRequest.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using BTCPayServer.Client.JsonConverters;
 using BTCPayServer.JsonConverters;
 using NBitcoin;
 using NBitcoin.JsonConverters;
@@ -22,7 +21,7 @@ namespace BTCPayServer.Client.Models
         public bool ProceedWithPayjoin { get; set; } = true;
         public bool ProceedWithBroadcast { get; set; } = true;
         public bool NoChange { get; set; } = false;
-        [JsonProperty(ItemConverterType = typeof(SaneOutpointJsonConverter))]
+        [JsonProperty(ItemConverterType = typeof(OutpointJsonConverter))]
         public List<OutPoint> SelectedInputs { get; set; } = null;
         public List<CreateOnChainTransactionRequestDestination> Destinations { get; set; }
         [JsonProperty("rbf")]

BTCPayServer.Client/Models/CreatePayoutThroughStoreRequest.cs

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

BTCPayServer.Client/Models/CustodianAccountBaseData.cs

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

BTCPayServer.Client/Models/CustodianAccountData.cs

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

BTCPayServer.Client/Models/CustodianAccountResponse.cs

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

BTCPayServer.Client/Models/CustodianData.cs

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

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

@@ -1,5 +1,3 @@
-using Newtonsoft.Json;
-
 namespace BTCPayServer.Client.Models;
 
 public class EmailSettingsData
@@ -28,11 +26,4 @@ public class EmailSettingsData
         get; set;
     }
     public bool DisableCertificateCheck { get; set; }
-
-    [JsonIgnore]
-    public bool EnabledCertificateCheck
-    {
-        get => !DisableCertificateCheck;
-        set { DisableCertificateCheck = !value; }
-    }
 }

BTCPayServer.Client/Models/GenerateOnChainWalletRequest.cs

@@ -1,10 +1,7 @@
-using System.Collections.Generic;
 using BTCPayServer.Client.JsonConverters;
-using BTCPayServer.Client.Models;
 using NBitcoin;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client
 {
@@ -25,16 +22,4 @@ namespace BTCPayServer.Client
         public bool ImportKeysToRPC { get; set; }
         public bool SavePrivateKeys { get; set; }
     }
-    public class GenerateOnChainWalletResponse : GenericPaymentMethodData
-    {
-        public class ConfigData
-        {
-            public string AccountDerivation { get; set; }
-            [JsonExtensionData]
-            IDictionary<string, JToken> AdditionalData { get; set; }
-        }
-        [JsonConverter(typeof(MnemonicJsonConverter))]
-        public Mnemonic Mnemonic { get; set; }
-        public new ConfigData Config { get; set; }
-    }
 }

BTCPayServer.Client/Models/GenericPaymentMethodData.cs

@@ -1,22 +1,9 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
 namespace BTCPayServer.Client.Models
 {
     public class GenericPaymentMethodData
     {
         public bool Enabled { get; set; }
-        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
-        public JToken Config { get; set; }
-        public string PaymentMethodId { get; set; }
-    }
-    public class UpdatePaymentMethodRequest
-    {
-        public UpdatePaymentMethodRequest()
-        {
-            
-        }
-        public bool? Enabled { get; set; }
-        public JToken Config { get; set; }
+        public object Data { get; set; }
+        public string CryptoCode { get; set; }
     }
 }

BTCPayServer.Client/Models/InvoiceExceptionStatus.cs

@@ -1,12 +1,12 @@
-namespace BTCPayServer.Client.Models;
-public enum InvoiceExceptionStatus
+namespace BTCPayServer.Client.Models
 {
-    None,
-    PaidLate,
-    PaidPartial,
-    Marked,
-    Invalid,
-    PaidOver
+    public enum InvoiceExceptionStatus
+    {
+        None,
+        PaidLate,
+        PaidPartial,
+        Marked,
+        Invalid,
+        PaidOver
+    }
 }
-
-

BTCPayServer.Client/Models/InvoicePaymentMethodDataModel.cs

@@ -29,12 +29,13 @@ namespace BTCPayServer.Client.Models
         public decimal Amount { get; set; }
 
         [JsonConverter(typeof(NumericStringJsonConverter))]
-        public decimal PaymentMethodFee { get; set; }
+        public decimal NetworkFee { get; set; }
 
         public List<Payment> Payments { get; set; }
-        public string PaymentMethodId { get; set; }
-        public JToken AdditionalData { get; set; }
-        public string Currency { get; set; }
+        public string PaymentMethod { get; set; }
+
+        public string CryptoCode { get; set; }
+        public JObject AdditionalData { get; set; }
 
         public class Payment
         {

BTCPayServer.Client/Models/LNURLPayPaymentMethodBaseData.cs

@@ -0,0 +1,13 @@
+namespace BTCPayServer.Client.Models
+{
+    public class LNURLPayPaymentMethodBaseData
+    {
+        public bool UseBech32Scheme { get; set; }
+        public bool LUD12Enabled { get; set; }
+
+        public LNURLPayPaymentMethodBaseData()
+        {
+
+        }
+    }
+}

BTCPayServer.Client/Models/LNURLPayPaymentMethodData.cs

@@ -0,0 +1,26 @@
+namespace BTCPayServer.Client.Models
+{
+    public class LNURLPayPaymentMethodData : LNURLPayPaymentMethodBaseData
+    {
+        /// <summary>
+        /// Whether the payment method is enabled
+        /// </summary>
+        public bool Enabled { get; set; }
+
+        /// <summary>
+        /// Crypto code of the payment method
+        /// </summary>
+        public string CryptoCode { get; set; }
+
+        public LNURLPayPaymentMethodData()
+        {
+        }
+
+        public LNURLPayPaymentMethodData(string cryptoCode, bool enabled, bool useBech32Scheme)
+        {
+            Enabled = enabled;
+            CryptoCode = cryptoCode;
+            UseBech32Scheme = useBech32Scheme;
+        }
+    }
+}

BTCPayServer.Client/Models/LightningAutomatedPayoutSettings.cs

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

BTCPayServer.Client/Models/LightningNetworkPaymentMethodBaseData.cs

@@ -0,0 +1,12 @@
+namespace BTCPayServer.Client.Models
+{
+    public class LightningNetworkPaymentMethodBaseData
+    {
+
+        public string ConnectionString { get; set; }
+        public LightningNetworkPaymentMethodBaseData()
+        {
+
+        }
+    }
+}

BTCPayServer.Client/Models/LightningNetworkPaymentMethodData.cs

@@ -0,0 +1,29 @@
+namespace BTCPayServer.Client.Models
+{
+    public class LightningNetworkPaymentMethodData : LightningNetworkPaymentMethodBaseData
+    {
+        /// <summary>
+        /// Whether the payment method is enabled
+        /// </summary>
+        public bool Enabled { get; set; }
+
+        /// <summary>
+        /// Crypto code of the payment method
+        /// </summary>
+        public string CryptoCode { get; set; }
+
+        public LightningNetworkPaymentMethodData()
+        {
+        }
+
+        public LightningNetworkPaymentMethodData(string cryptoCode, string connectionString, bool enabled, string paymentMethod)
+        {
+            Enabled = enabled;
+            CryptoCode = cryptoCode;
+            ConnectionString = connectionString;
+            PaymentMethod = paymentMethod;
+        }
+
+        public string PaymentMethod { 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

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

BTCPayServer.Client/Models/OnChainPaymentMethodBaseData.cs

@@ -0,0 +1,24 @@
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class OnChainPaymentMethodBaseData
+    {
+        /// <summary>
+        /// The derivation scheme
+        /// </summary>
+        public string DerivationScheme { get; set; }
+
+        public string Label { get; set; }
+
+        [JsonConverter(typeof(NBitcoin.JsonConverters.KeyPathJsonConverter))]
+        public RootedKeyPath AccountKeyPath { get; set; }
+
+        public OnChainPaymentMethodBaseData()
+        {
+        }
+
+
+    }
+}

BTCPayServer.Client/Models/OnChainPaymentMethodData.cs

@@ -0,0 +1,47 @@
+using NBitcoin;
+
+namespace BTCPayServer.Client.Models
+{
+    public class OnChainPaymentMethodDataPreview : OnChainPaymentMethodBaseData
+    {
+        /// <summary>
+        /// Crypto code of the payment method
+        /// </summary>
+        public string CryptoCode { get; set; }
+
+        public OnChainPaymentMethodDataPreview()
+        {
+
+        }
+
+        public OnChainPaymentMethodDataPreview(string cryptoCode, string derivationScheme, string label, RootedKeyPath accountKeyPath)
+        {
+            Label = label;
+            AccountKeyPath = accountKeyPath;
+            CryptoCode = cryptoCode;
+            DerivationScheme = derivationScheme;
+        }
+    }
+
+    public class OnChainPaymentMethodData : OnChainPaymentMethodDataPreview
+    {
+        /// <summary>
+        /// Whether the payment method is enabled
+        /// </summary>
+        public bool Enabled { get; set; }
+
+        public string PaymentMethod { get; set; }
+
+        public OnChainPaymentMethodData()
+        {
+
+        }
+
+        public OnChainPaymentMethodData(string cryptoCode, string derivationScheme, bool enabled, string label, RootedKeyPath accountKeyPath, string paymentMethod) :
+            base(cryptoCode, derivationScheme, label, accountKeyPath)
+        {
+            Enabled = enabled;
+            PaymentMethod = paymentMethod;
+        }
+    }
+}

BTCPayServer.Client/Models/OnChainPaymentMethodDataWithSensitiveData.cs

@@ -0,0 +1,23 @@
+using BTCPayServer.Client.JsonConverters;
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class OnChainPaymentMethodDataWithSensitiveData : OnChainPaymentMethodData
+    {
+        public OnChainPaymentMethodDataWithSensitiveData()
+        {
+        }
+
+        public OnChainPaymentMethodDataWithSensitiveData(string cryptoCode, string derivationScheme, bool enabled,
+            string label, RootedKeyPath accountKeyPath, Mnemonic mnemonic, string paymentMethod) : base(cryptoCode, derivationScheme, enabled,
+            label, accountKeyPath, paymentMethod)
+        {
+            Mnemonic = mnemonic;
+        }
+
+        [JsonConverter(typeof(MnemonicJsonConverter))]
+        public Mnemonic Mnemonic { get; set; }
+    }
+}

BTCPayServer.Client/Models/OnChainWalletUTXOData.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using BTCPayServer.Client.JsonConverters;
 using BTCPayServer.JsonConverters;
 using NBitcoin;
 using NBitcoin.JsonConverters;
@@ -13,7 +12,7 @@ namespace BTCPayServer.Client.Models
         public string Comment { get; set; }
         [JsonConverter(typeof(NumericStringJsonConverter))]
         public decimal Amount { get; set; }
-        [JsonConverter(typeof(SaneOutpointJsonConverter))]
+        [JsonConverter(typeof(OutpointJsonConverter))]
         public OutPoint Outpoint { get; set; }
         public string Link { get; set; }
 #pragma warning disable CS0612 // Type or member is obsolete

BTCPayServer.Client/Models/PaymentRequestData.cs

@@ -7,7 +7,7 @@ namespace BTCPayServer.Client.Models
     public class PaymentRequestData : PaymentRequestBaseData
     {
         [JsonConverter(typeof(StringEnumConverter))]
-        public PaymentRequestStatus Status { get; set; }
+        public PaymentRequestData.PaymentRequestStatus Status { get; set; }
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset CreatedTime { get; set; }
         public string Id { get; set; }
@@ -16,8 +16,7 @@ namespace BTCPayServer.Client.Models
         {
             Pending = 0,
             Completed = 1,
-            Expired = 2,
-            Processing = 3
+            Expired = 2
         }
     }
 }

BTCPayServer.Client/Models/PayoutData.cs

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

BTCPayServer.Client/Models/PointOfSaleAppData.cs

@@ -9,8 +9,6 @@ namespace BTCPayServer.Client.Models
         public string AppType { get; set; }
         public string Name { get; set; }
         public string StoreId { get; set; }
-        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public bool? Archived { get; set; }
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset Created { get; set; }
     }
@@ -19,11 +17,8 @@ namespace BTCPayServer.Client.Models
     {
         public string Title { get; set; }
         public string DefaultView { get; set; }
-        public bool ShowItems { get; set; }
         public bool ShowCustomAmount { get; set; }
         public bool ShowDiscount { get; set; }
-        public bool ShowSearch { get; set; }
-        public bool ShowCategories { get; set; }
         public bool EnableTips { get; set; }
         public string Currency { get; set; }
         public object Items { get; set; }

BTCPayServer.Client/Models/RegisterBoltcardRequest.cs

@@ -1,44 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using NBitcoin.JsonConverters;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Client.Models
-{
-    public enum OnExistingBehavior
-    {
-        KeepVersion,
-        UpdateVersion
-    }
-    public class RegisterBoltcardRequest
-    {
-        [JsonProperty("LNURLW")]
-        public string LNURLW { get; set; }
-        [JsonConverter(typeof(HexJsonConverter))]
-        [JsonProperty("UID")]
-        public byte[] UID { get; set; }
-        [JsonConverter(typeof(StringEnumConverter))]
-        public OnExistingBehavior? OnExisting { get; set; }
-        [JsonExtensionData]
-        public IDictionary<string, JToken> AdditionalData { get; set; } = new Dictionary<string, JToken>();
-    }
-    public class RegisterBoltcardResponse
-    {
-        [JsonProperty("LNURLW")]
-        public string LNURLW { get; set; }
-        public int Version { get; set; }
-        [JsonProperty("K0")]
-        public string K0 { get; set; }
-        [JsonProperty("K1")]
-        public string K1 { get; set; }
-        [JsonProperty("K2")]
-        public string K2 { get; set; }
-        [JsonProperty("K3")]
-        public string K3 { get; set; }
-        [JsonProperty("K4")]
-        public string K4 { get; set; }
-    }
-}

BTCPayServer.Client/Models/StoreBaseData.cs

@@ -37,20 +37,14 @@ namespace BTCPayServer.Client.Models
         public bool AnyoneCanCreateInvoice { get; set; }
         public string DefaultCurrency { get; set; }
         public bool RequiresRefundEmail { get; set; }
-
         [JsonConverter(typeof(StringEnumConverter))]
-        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public CheckoutType? CheckoutType { get; set; }
-
+        public CheckoutType CheckoutType { get; set; }
         public bool LightningAmountInSatoshi { get; set; }
         public bool LightningPrivateRouteHints { get; set; }
         public bool OnChainWithLnInvoiceFallback { get; set; }
         public bool LazyPaymentMethods { get; set; }
         public bool RedirectAutomatically { get; set; }
 
-        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public bool Archived { get; set; }
-
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public bool ShowRecommendedFee { get; set; } = true;
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
@@ -76,17 +70,6 @@ namespace BTCPayServer.Client.Models
 
         public bool PayJoinEnabled { get; set; }
 
-        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public bool? AutoDetectLanguage { get; set; }
-        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public bool? ShowPayInWalletButton { get; set; }
-        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public bool? ShowStoreHeader { get; set; }
-        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public bool? CelebratePayment { get; set; }
-        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public bool? PlaySoundOnPayment { get; set; }
-
         public InvoiceData.ReceiptOptions Receipt { get; set; }
 
 

BTCPayServer.Client/Models/StoreData.cs

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

BTCPayServer.Client/Models/StoreReportRequest.cs

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

BTCPayServer.Client/Models/StoreReportsResponse.cs

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

BTCPayServer.Client/Models/StoreWebhookData.cs

@@ -11,7 +11,8 @@ namespace BTCPayServer.Client.Models
         {
             public bool Everything { get; set; } = true;
 
-            public string[] SpecificEvents { get; set; } = Array.Empty<string>();
+            [JsonProperty(ItemConverterType = typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
+            public WebhookEventType[] SpecificEvents { get; set; } = Array.Empty<WebhookEventType>();
         }
 
         public bool Enabled { get; set; } = true;

BTCPayServer.Client/Models/TradeQuoteResponseData.cs

@@ -0,0 +1,22 @@
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class TradeQuoteResponseData
+{
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal Bid { get; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal Ask { get; }
+    public string ToAsset { get; }
+    public string FromAsset { get; }
+
+    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,11 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class TradeRequestData
+{
+    public string FromAsset { set; get; }
+    public string ToAsset { set; get; }
+    [JsonConverter(typeof(JsonConverters.TradeQuantityJsonConverter))]
+    public TradeQuantity Qty { set; get; }
+}

BTCPayServer.Client/Models/UpdateLightningNetworkPaymentMethodRequest.cs

@@ -0,0 +1,20 @@
+namespace BTCPayServer.Client.Models
+{
+    public class UpdateLightningNetworkPaymentMethodRequest : LightningNetworkPaymentMethodBaseData
+    {
+        /// <summary>
+        /// Whether the payment method is enabled
+        /// </summary>
+        public bool Enabled { get; set; }
+
+        public UpdateLightningNetworkPaymentMethodRequest()
+        {
+        }
+
+        public UpdateLightningNetworkPaymentMethodRequest(string connectionString, bool enabled)
+        {
+            Enabled = enabled;
+            ConnectionString = connectionString;
+        }
+    }
+}

BTCPayServer.Client/Models/UpdateOnChainPaymentMethodRequest.cs

@@ -0,0 +1,25 @@
+using NBitcoin;
+
+namespace BTCPayServer.Client.Models
+{
+    public class UpdateOnChainPaymentMethodRequest : OnChainPaymentMethodBaseData
+    {
+        /// <summary>
+        /// Whether the payment method is enabled
+        /// </summary>
+        public bool Enabled { get; set; }
+
+        public UpdateOnChainPaymentMethodRequest()
+        {
+
+        }
+
+        public UpdateOnChainPaymentMethodRequest(bool enabled, string derivationScheme, string label, RootedKeyPath accountKeyPath)
+        {
+            Enabled = enabled;
+            Label = label;
+            AccountKeyPath = accountKeyPath;
+            DerivationScheme = derivationScheme;
+        }
+    }
+}

BTCPayServer.Client/Models/WebhookEvent.cs

@@ -9,7 +9,7 @@ namespace BTCPayServer.Client.Models
 {
     public class WebhookEvent
     {
-        public static readonly JsonSerializerSettings DefaultSerializerSettings;
+        public readonly static JsonSerializerSettings DefaultSerializerSettings;
         static WebhookEvent()
         {
             DefaultSerializerSettings = new JsonSerializerSettings();
@@ -45,15 +45,12 @@ namespace BTCPayServer.Client.Models
             }
         }
         public bool IsRedelivery { get; set; }
-        public string Type { get; set; }
+        [JsonConverter(typeof(StringEnumConverter))]
+        public WebhookEventType Type { get; set; }
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset Timestamp { get; set; }
         [JsonExtensionData]
         public IDictionary<string, JToken> AdditionalData { get; set; }
-        public bool IsPruned()
-        {
-            return DeliveryId is null;
-        }
         public T ReadAs<T>()
         {
             var str = JsonConvert.SerializeObject(this, DefaultSerializerSettings);

BTCPayServer.Client/Models/WebhookEventType.cs

@@ -1,20 +1,13 @@
-namespace BTCPayServer.Client.Models;
-
-public static class WebhookEventType
+namespace BTCPayServer.Client.Models
 {
-    public const string InvoiceCreated = nameof(InvoiceCreated);
-    public const string InvoiceReceivedPayment = nameof(InvoiceReceivedPayment);
-    public const string InvoiceProcessing = nameof(InvoiceProcessing);
-    public const string InvoiceExpired = nameof(InvoiceExpired);
-    public const string InvoiceSettled = nameof(InvoiceSettled);
-    public const string InvoiceInvalid = nameof(InvoiceInvalid);
-    public const string InvoicePaymentSettled = nameof(InvoicePaymentSettled);
-    public const string PayoutCreated = nameof(PayoutCreated);
-    public const string PayoutApproved = nameof(PayoutApproved);
-    public const string PayoutUpdated = nameof(PayoutUpdated);
-    public const string PaymentRequestUpdated = nameof(PaymentRequestUpdated);
-    public const string PaymentRequestCreated = nameof(PaymentRequestCreated);
-    public const string PaymentRequestArchived = nameof(PaymentRequestArchived);
-    public const string PaymentRequestStatusChanged = nameof(PaymentRequestStatusChanged);
-    
+    public enum WebhookEventType
+    {
+        InvoiceCreated,
+        InvoiceReceivedPayment,
+        InvoiceProcessing,
+        InvoiceExpired,
+        InvoiceSettled,
+        InvoiceInvalid,
+        InvoicePaymentSettled,
+    }
 }

BTCPayServer.Client/Models/WebhookInvoiceEvent.cs

@@ -1,74 +1,44 @@
-using System;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client.Models
 {
-    public class WebhookPayoutEvent : StoreWebhookEvent
-    {
-        public WebhookPayoutEvent(string type, string storeId)
-        {
-            if (!type.StartsWith("payout", StringComparison.InvariantCultureIgnoreCase))
-                throw new ArgumentException("Invalid event type", nameof(type));
-            Type = type;
-            StoreId = storeId;
-        }
-
-        [JsonProperty(Order = 2)] public string PayoutId { get; set; }
-        [JsonProperty(Order = 3)] public string PullPaymentId { get; set; }
-        [JsonProperty(Order = 4)] [JsonConverter(typeof(StringEnumConverter))]public PayoutState PayoutState { get; set; }
-    } 
-    public class WebhookPaymentRequestEvent : StoreWebhookEvent
-    {
-        public WebhookPaymentRequestEvent(string type, string storeId)
-        {
-            if (!type.StartsWith("paymentrequest", StringComparison.InvariantCultureIgnoreCase))
-                throw new ArgumentException("Invalid event type", nameof(type));
-            Type = type;
-            StoreId = storeId;
-        }
-
-        [JsonProperty(Order = 2)] public string PaymentRequestId { get; set; }
-        [JsonProperty(Order = 3)] [JsonConverter(typeof(StringEnumConverter))]public PaymentRequestData.PaymentRequestStatus Status { get; set; }
-    }
-    
-    public abstract class StoreWebhookEvent : WebhookEvent
-    {
-        [JsonProperty(Order = 1)] public string StoreId { get; set; }
-    }
-    
-    public class WebhookInvoiceEvent : StoreWebhookEvent
+    public class WebhookInvoiceEvent : WebhookEvent
     {
         public WebhookInvoiceEvent()
         {
         }
 
-        public WebhookInvoiceEvent(string evtType, string storeId)
-        { 
-            if (!evtType.StartsWith("invoice", StringComparison.InvariantCultureIgnoreCase))
-                throw new ArgumentException("Invalid event type", nameof(evtType));
-            Type = evtType;
-            StoreId = storeId;
+        public WebhookInvoiceEvent(WebhookEventType evtType)
+        {
+            this.Type = evtType;
         }
 
+        [JsonProperty(Order = 1)] public string StoreId { get; set; }
         [JsonProperty(Order = 2)] public string InvoiceId { get; set; }
         [JsonProperty(Order = 3)] public JObject Metadata { get; set; }
     }
 
     public class WebhookInvoiceSettledEvent : WebhookInvoiceEvent
     {
-        public WebhookInvoiceSettledEvent(string storeId) : base(WebhookEventType.InvoiceSettled, storeId)
+        public WebhookInvoiceSettledEvent()
+        {
+        }
+
+        public WebhookInvoiceSettledEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 
         public bool ManuallyMarked { get; set; }
-        public bool OverPaid { get; set; }
     }
 
     public class WebhookInvoiceInvalidEvent : WebhookInvoiceEvent
     {
-        public WebhookInvoiceInvalidEvent(string storeId) : base(WebhookEventType.InvoiceInvalid, storeId)
+        public WebhookInvoiceInvalidEvent()
+        {
+        }
+
+        public WebhookInvoiceInvalidEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 
@@ -77,7 +47,11 @@ namespace BTCPayServer.Client.Models
 
     public class WebhookInvoiceProcessingEvent : WebhookInvoiceEvent
     {
-        public WebhookInvoiceProcessingEvent(string storeId) : base(WebhookEventType.InvoiceProcessing, storeId)
+        public WebhookInvoiceProcessingEvent()
+        {
+        }
+
+        public WebhookInvoiceProcessingEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 
@@ -86,25 +60,38 @@ namespace BTCPayServer.Client.Models
 
     public class WebhookInvoiceReceivedPaymentEvent : WebhookInvoiceEvent
     {
-        public WebhookInvoiceReceivedPaymentEvent(string type, string storeId) : base(type, storeId)
+        public WebhookInvoiceReceivedPaymentEvent()
+        {
+        }
+
+        public WebhookInvoiceReceivedPaymentEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 
         public bool AfterExpiration { get; set; }
-        public string PaymentMethodId { get; set; }
+        public string PaymentMethod { get; set; }
         public InvoicePaymentMethodDataModel.Payment Payment { get; set; }
+        public bool OverPaid { get; set; }
     }
 
     public class WebhookInvoicePaymentSettledEvent : WebhookInvoiceReceivedPaymentEvent
     {
-        public WebhookInvoicePaymentSettledEvent(string storeId) : base(WebhookEventType.InvoicePaymentSettled, storeId)
+        public WebhookInvoicePaymentSettledEvent()
+        {
+        }
+
+        public WebhookInvoicePaymentSettledEvent(WebhookEventType evtType) : base(evtType)
         {
         }
     }
 
     public class WebhookInvoiceExpiredEvent : WebhookInvoiceEvent
     {
-        public WebhookInvoiceExpiredEvent(string storeId) : base(WebhookEventType.InvoiceExpired, storeId)
+        public WebhookInvoiceExpiredEvent()
+        {
+        }
+
+        public WebhookInvoiceExpiredEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 

BTCPayServer.Client/Models/WithdrawRequestData.cs

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

BTCPayServer.Client/Models/WithdrawalBaseResponseData.cs

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

BTCPayServer.Client/Models/WithdrawalResponseData.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models;
+
+public class WithdrawalResponseData : WithdrawalBaseResponseData
+{
+
+    [JsonConverter(typeof(StringEnumConverter))]
+    public WithdrawalStatus Status { get; }
+
+    public string WithdrawalId { 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) : base(paymentMethod, asset, ledgerEntries, accountId,
+        custodianCode)
+    {
+        WithdrawalId = withdrawalId;
+        TargetAddress = targetAddress;
+        TransactionId = transactionId;
+        Status = status;
+        CreatedTime = createdTime;
+    }
+
+
+    public enum WithdrawalStatus
+    {
+        Unknown = 0,
+        Queued = 1,
+        Complete = 2,
+        Failed = 3
+    }
+}

BTCPayServer.Client/Models/WithdrawalSimulationResponseData.cs

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

BTCPayServer.Client/Permissions.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
-using System.Linq.Expressions;
 
 namespace BTCPayServer.Client
 {
@@ -19,7 +17,6 @@ namespace BTCPayServer.Client
         public const string CanModifyStoreWebhooks = "btcpay.store.webhooks.canmodifywebhooks";
         public const string CanModifyStoreSettingsUnscoped = "btcpay.store.canmodifystoresettings:";
         public const string CanViewStoreSettings = "btcpay.store.canviewstoresettings";
-        public const string CanViewReports = "btcpay.store.canviewreports";
         public const string CanViewInvoices = "btcpay.store.canviewinvoices";
         public const string CanCreateInvoice = "btcpay.store.cancreateinvoice";
         public const string CanModifyInvoices = "btcpay.store.canmodifyinvoices";
@@ -34,12 +31,13 @@ namespace BTCPayServer.Client
         public const string CanManageUsers = "btcpay.server.canmanageusers";
         public const string CanDeleteUser = "btcpay.user.candeleteuser";
         public const string CanManagePullPayments = "btcpay.store.canmanagepullpayments";
-        public const string CanArchivePullPayments = "btcpay.store.canarchivepullpayments";
-        public const string CanManagePayouts = "btcpay.store.canmanagepayouts";
-        public const string CanViewPayouts = "btcpay.store.canviewpayouts";
         public const string CanCreatePullPayments = "btcpay.store.cancreatepullpayments";
-        public const string CanViewPullPayments = "btcpay.store.canviewpullpayments";
         public const string CanCreateNonApprovedPullPayments = "btcpay.store.cancreatenonapprovedpullpayments";
+        public const string CanViewCustodianAccounts = "btcpay.store.canviewcustodianaccounts";
+        public const string CanManageCustodianAccounts = "btcpay.store.canmanagecustodianaccounts";
+        public const string CanDepositToCustodianAccounts = "btcpay.store.candeposittocustodianaccount";
+        public const string CanWithdrawFromCustodianAccounts = "btcpay.store.canwithdrawfromcustodianaccount";
+        public const string CanTradeCustodianAccount = "btcpay.store.cantradecustodianaccount";
         public const string Unrestricted = "unrestricted";
         public static IEnumerable<string> AllPolicies
         {
@@ -52,7 +50,6 @@ namespace BTCPayServer.Client
                 yield return CanModifyServerSettings;
                 yield return CanModifyStoreSettings;
                 yield return CanViewStoreSettings;
-                yield return CanViewReports;
                 yield return CanViewPaymentRequests;
                 yield return CanModifyPaymentRequests;
                 yield return CanModifyProfile;
@@ -70,13 +67,14 @@ namespace BTCPayServer.Client
                 yield return CanViewLightningInvoiceInStore;
                 yield return CanCreateLightningInvoiceInStore;
                 yield return CanManagePullPayments;
-                yield return CanArchivePullPayments;
                 yield return CanCreatePullPayments;
-                yield return CanViewPullPayments;
                 yield return CanCreateNonApprovedPullPayments;
+                yield return CanViewCustodianAccounts;
+                yield return CanManageCustodianAccounts;
+                yield return CanDepositToCustodianAccounts;
+                yield return CanWithdrawFromCustodianAccounts;
+                yield return CanTradeCustodianAccount;
                 yield return CanManageUsers;
-                yield return CanManagePayouts;
-                yield return CanViewPayouts;
             }
         }
         public static bool IsValidPolicy(string policy)
@@ -136,7 +134,7 @@ namespace BTCPayServer.Client
     {
         static Permission()
         {
-            PolicyMap = Init();
+            Init();
         }
 
         public static Permission Create(string policy, string scope = null)
@@ -237,58 +235,38 @@ namespace BTCPayServer.Client
             return subPolicies.Contains(subpolicy) || subPolicies.Any(s => ContainsPolicy(s, subpolicy));
         }
 
-        public static ReadOnlyDictionary<string, HashSet<string>> PolicyMap { get; private set; }
-    
+        private static Dictionary<string, HashSet<string>> PolicyMap = new();
 
-        private static ReadOnlyDictionary<string, HashSet<string>> Init()
+        private static void Init()
         {
-            var policyMap = new Dictionary<string, HashSet<string>>();
-            PolicyHasChild(policyMap, Policies.CanModifyStoreSettings,
+            PolicyHasChild(Policies.CanModifyStoreSettings,
+                Policies.CanManageCustodianAccounts,
                 Policies.CanManagePullPayments,
                 Policies.CanModifyInvoices,
                 Policies.CanViewStoreSettings,
                 Policies.CanModifyStoreWebhooks,
                 Policies.CanModifyPaymentRequests,
-                Policies.CanManagePayouts,
                 Policies.CanUseLightningNodeInStore);
 
-            PolicyHasChild(policyMap,Policies.CanManageUsers, Policies.CanCreateUser);
-            PolicyHasChild(policyMap,Policies.CanManagePullPayments, Policies.CanCreatePullPayments, Policies.CanArchivePullPayments);
-            PolicyHasChild(policyMap,Policies.CanCreatePullPayments, Policies.CanCreateNonApprovedPullPayments);
-            PolicyHasChild(policyMap, Policies.CanCreateNonApprovedPullPayments, Policies.CanViewPullPayments);
-            PolicyHasChild(policyMap,Policies.CanModifyPaymentRequests, Policies.CanViewPaymentRequests);
-            PolicyHasChild(policyMap,Policies.CanModifyProfile, Policies.CanViewProfile);
-            PolicyHasChild(policyMap,Policies.CanUseLightningNodeInStore, Policies.CanViewLightningInvoiceInStore, Policies.CanCreateLightningInvoiceInStore);
-            PolicyHasChild(policyMap,Policies.CanManageNotificationsForUser, Policies.CanViewNotificationsForUser);
-            PolicyHasChild(policyMap,Policies.CanModifyServerSettings,
+            PolicyHasChild(Policies.CanManageUsers, Policies.CanCreateUser);
+            PolicyHasChild(Policies.CanManagePullPayments, Policies.CanCreatePullPayments);
+            PolicyHasChild(Policies.CanCreatePullPayments, Policies.CanCreateNonApprovedPullPayments);
+            PolicyHasChild(Policies.CanModifyPaymentRequests, Policies.CanViewPaymentRequests);
+            PolicyHasChild(Policies.CanModifyProfile, Policies.CanViewProfile);
+            PolicyHasChild(Policies.CanUseLightningNodeInStore, Policies.CanViewLightningInvoiceInStore, Policies.CanCreateLightningInvoiceInStore);
+            PolicyHasChild(Policies.CanManageNotificationsForUser, Policies.CanViewNotificationsForUser);
+            PolicyHasChild(Policies.CanModifyServerSettings,
                 Policies.CanUseInternalLightningNode,
                 Policies.CanManageUsers);
-            PolicyHasChild(policyMap, Policies.CanUseInternalLightningNode, Policies.CanCreateLightningInvoiceInternalNode, Policies.CanViewLightningInvoiceInternalNode);
-            PolicyHasChild(policyMap, Policies.CanModifyInvoices, Policies.CanViewInvoices, Policies.CanCreateInvoice, Policies.CanCreateLightningInvoiceInStore);
-            PolicyHasChild(policyMap, Policies.CanViewStoreSettings, Policies.CanViewInvoices, Policies.CanViewPaymentRequests, Policies.CanViewReports, Policies.CanViewPullPayments, Policies.CanViewPayouts);
-            PolicyHasChild(policyMap, Policies.CanManagePayouts, Policies.CanViewPayouts);
-
-            var missingPolicies = Policies.AllPolicies.ToHashSet();
-            //recurse through the tree to see which policies are not included in the tree
-            foreach (var policy in policyMap)
-            {
-                missingPolicies.Remove(policy.Key);
-                foreach (var subPolicy in policy.Value)
-                {
-                    missingPolicies.Remove(subPolicy);
-                }
-            }
-
-            foreach (var missingPolicy in missingPolicies)
-            {
-                policyMap.Add(missingPolicy, new HashSet<string>());
-            }
-            return new ReadOnlyDictionary<string, HashSet<string>>(policyMap);
+            PolicyHasChild(Policies.CanUseInternalLightningNode, Policies.CanCreateLightningInvoiceInternalNode, Policies.CanViewLightningInvoiceInternalNode);
+            PolicyHasChild(Policies.CanManageCustodianAccounts, Policies.CanViewCustodianAccounts);
+            PolicyHasChild(Policies.CanModifyInvoices, Policies.CanViewInvoices, Policies.CanCreateInvoice, Policies.CanCreateLightningInvoiceInStore);
+            PolicyHasChild(Policies.CanViewStoreSettings, Policies.CanViewInvoices, Policies.CanViewPaymentRequests);
         }
 
-        private static void PolicyHasChild(Dictionary<string, HashSet<string>>policyMap, string policy, params string[] subPolicies)
+        private static void PolicyHasChild(string policy, params string[] subPolicies)
         {
-            if (policyMap.TryGetValue(policy, out var existingSubPolicies))
+            if (PolicyMap.TryGetValue(policy, out var existingSubPolicies))
             {
                 foreach (string subPolicy in subPolicies)
                 {
@@ -297,7 +275,7 @@ namespace BTCPayServer.Client
             }
             else
             {
-                policyMap.Add(policy, subPolicies.ToHashSet());
+                PolicyMap.Add(policy, subPolicies.ToHashSet());
             }
         }
 

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Althash.cs

@@ -0,0 +1,28 @@
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitAlthash()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("HTML");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Htmlcoin",
+                BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://explorer.htmlcoin.com/api/tx/{0}" : "https://explorer.htmlcoin.com/api/tx/{0}",
+                NBXplorerNetwork = nbxplorerNetwork,
+                DefaultRateRules = new[]
+                {
+                                "HTML_X = HTML_USD",
+                                "HTML_USD = hitbtc(HTML_USD)"
+                },
+                CryptoImagePath = "imlegacy/althash.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("172'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Argoneum.cs

@@ -0,0 +1,30 @@
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitArgoneum()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("AGM");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Argoneum",
+                BlockExplorerLink = NetworkType == ChainName.Mainnet
+                    ? "https://chainz.cryptoid.info/agm/tx.dws?{0}"
+                    : "https://chainz.cryptoid.info/agm-test/tx.dws?{0}",
+                NBXplorerNetwork = nbxplorerNetwork,
+                DefaultRateRules = new[]
+                    {
+                        "AGM_X = AGM_BTC * BTC_X",
+                        "AGM_BTC = argoneum(AGM_BTC)"
+                    },
+                CryptoImagePath = "imlegacy/argoneum.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("421'")
+                    : new KeyPath("1'")
+            });
+        }
+    }
+}