diff --git a/src/Data/Models/WalletWithdrawalRequest.cs b/src/Data/Models/WalletWithdrawalRequest.cs
index 4d8bdd9c..b3d25332 100644
--- a/src/Data/Models/WalletWithdrawalRequest.cs
+++ b/src/Data/Models/WalletWithdrawalRequest.cs
@@ -147,6 +147,11 @@ public class WalletWithdrawalRequest : Entity, IEquatable<WalletWithdrawalReques
         /// </summary>
         public decimal? CustomFeeRate { get; set; }
 
+        /// <summary>
+        /// Coin selection strategy requested for this withdrawal. Null means the requestor did not pick one.
+        /// </summary>
+        public CoinSelectionStrategy? CoinSelectionStrategy { get; set; }
+
         /// <summary>
         /// Check that the number of signatures (not finalised psbt nor internal wallet psbt or template psbt are gathered and increases by one to count on the internal wallet signature
         /// </summary>
diff --git a/src/Migrations/20260918121451_AddWithdrawalCoinSelectionStrategy.Designer.cs b/src/Migrations/20260918121451_AddWithdrawalCoinSelectionStrategy.Designer.cs
new file mode 100644
index 00000000..6cbf48fa
--- /dev/null
+++ b/src/Migrations/20260918121451_AddWithdrawalCoinSelectionStrategy.Designer.cs
@@ -0,0 +1,1944 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using NodeGuard.Data;
+using NodeGuard.Helpers;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace NodeGuard.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260918121451_AddWithdrawalCoinSelectionStrategy")]
+    partial class AddWithdrawalCoinSelectionStrategy
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("ApplicationUserNode", b =>
+                {
+                    b.Property<int>("NodesId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UsersId")
+                        .HasColumnType("text");
+
+                    b.HasKey("NodesId", "UsersId");
+
+                    b.HasIndex("UsersId");
+
+                    b.ToTable("ApplicationUserNode");
+                });
+
+            modelBuilder.Entity("ChannelOperationRequestFMUTXO", b =>
+                {
+                    b.Property<int>("ChannelOperationRequestsId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UtxosId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChannelOperationRequestsId", "UtxosId");
+
+                    b.HasIndex("UtxosId");
+
+                    b.ToTable("ChannelOperationRequestFMUTXO");
+                });
+
+            modelBuilder.Entity("FMUTXOWalletWithdrawalRequest", b =>
+                {
+                    b.Property<int>("UTXOsId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("WalletWithdrawalRequestsId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("UTXOsId", "WalletWithdrawalRequestsId");
+
+                    b.HasIndex("WalletWithdrawalRequestsId");
+
+                    b.ToTable("FMUTXOWalletWithdrawalRequest");
+                });
+
+            modelBuilder.Entity("KeyWallet", b =>
+                {
+                    b.Property<int>("KeysId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("WalletsId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("KeysId", "WalletsId");
+
+                    b.HasIndex("WalletsId");
+
+                    b.ToTable("KeyWallet");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Discriminator")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("character varying(21)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+
+                    b.HasDiscriminator().HasValue("IdentityUser");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.APIToken", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatorId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ExpirationDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("IsBlocked")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.ToTable("ApiTokens");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.AuditLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ActionType")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("text");
+
+                    b.Property<int>("EventType")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("IpAddress")
+                        .HasMaxLength(45)
+                        .HasColumnType("character varying(45)");
+
+                    b.Property<int>("ObjectAffected")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ObjectId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<string>("Username")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AuditLogs");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Channel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BtcCloseAddress")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("ChanId")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<DateTimeOffset?>("ClosedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("CreatedByNodeGuard")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("DestinationNodeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FundingTx")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("FundingTxOutputIndex")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsAutoRebalanceEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("IsAutomatedLiquidityEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDynamicFeeEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<bool>("IsPrivate")
+                        .HasColumnType("boolean");
+
+                    b.Property<long>("SatsAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SourceNodeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DestinationNodeId");
+
+                    b.HasIndex("SourceNodeId");
+
+                    b.ToTable("Channels");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelFeeState", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChannelId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("LastAppliedInboundBaseMsat")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LastAppliedInboundPpm")
+                        .HasColumnType("integer");
+
+                    b.Property<long?>("LastAppliedOutboundBaseFeeMsat")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("LastAppliedOutboundPpm")
+                        .HasColumnType("bigint");
+
+                    b.Property<double?>("LastComputedTarget")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTimeOffset?>("LastFeeUpdateAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double?>("LastObservedRatio")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("ManagedNodePubKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId", "ManagedNodePubKey")
+                        .IsUnique();
+
+                    b.ToTable("ChannelFeeStates");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelOperationRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AmountCryptoUnit")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Changeless")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("ChannelId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ClosingReason")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("DestNodeId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("FeeRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<long?>("InitialChannelBaseFeeMsat")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("InitialChannelFeeRatePpm")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsChannelPrivate")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MempoolRecommendedFeesType")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RequestType")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("SatsAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SourceNodeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<List<ChannelStatusLog>>("StatusLogs")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("TxId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("WalletId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("DestNodeId");
+
+                    b.HasIndex("SourceNodeId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("ChannelOperationRequests");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelOperationRequestPSBT", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChannelOperationRequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsFinalisedPSBT")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInternalWalletPSBT")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsTemplatePSBT")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PSBT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserSignerId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelOperationRequestId");
+
+                    b.HasIndex("UserSignerId");
+
+                    b.HasIndex(new[] { "ChannelOperationRequestId" }, "IX_ChannelOperationRequestPSBTs_Template")
+                        .IsUnique()
+                        .HasFilter("\"IsTemplatePSBT\"");
+
+                    b.ToTable("ChannelOperationRequestPSBTs");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelRoutingState", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<long?>("AgeBlocks")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal>("ChanIdLnd")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<int>("ChannelId")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("ConsecutiveCategoryCyclesInNewState")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("EmaLocalRatio")
+                        .HasColumnType("double precision");
+
+                    b.Property<long?>("FundingBlockHeight")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset?>("LastCategorizedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("LastEvaluatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("LastKnownLifetime")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("LastKnownNumUpdates")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("LastKnownUptime")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ManagedNodePubKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<double>("NetFlowRatio")
+                        .HasColumnType("double precision");
+
+                    b.Property<int>("PeerFlowCategory")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("PeerInitiated")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("PendingCategory")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("PullMsatWindow")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PushMsatWindow")
+                        .HasColumnType("bigint");
+
+                    b.Property<double>("TargetLocalRatio")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId", "ManagedNodePubKey")
+                        .IsUnique();
+
+                    b.ToTable("ChannelRoutingStates");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.FMUTXO", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("OutputIndex")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("SatsAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("TxId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FMUTXOs");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ForwardingHtlcEvent", b =>
+                {
+                    b.Property<string>("ManagedNodePubKey")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("IncomingChannelId")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<decimal>("OutgoingChannelId")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<decimal>("IncomingHtlcId")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<decimal>("OutgoingHtlcId")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EventCase")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("EventTimestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EventType")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("FailureDetail")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FailureString")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<long?>("FeeMsat")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("GrossFeeMsat")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("InboundFeeMsat")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("InboundFeePpm")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal?>("IncomingAmountMsat")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<string>("IncomingPeerAlias")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long?>("IncomingTimelock")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ManagedNodeName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Outcome")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("OutgoingAmountMsat")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<string>("OutgoingPeerAlias")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long?>("OutgoingTimelock")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("RoutingFeePpm")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("WireFailureCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ManagedNodePubKey", "IncomingChannelId", "OutgoingChannelId", "IncomingHtlcId", "OutgoingHtlcId");
+
+                    b.HasIndex("CreationDatetime");
+
+                    b.HasIndex("EventTimestamp");
+
+                    b.ToTable("ForwardingHtlcEvents");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.InternalWallet", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DerivationPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFingerprint")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MnemonicString")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("XPUB")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("InternalWallets");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Key", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InternalWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsBIP39ImportedKey")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsCompromised")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("MasterFingerprint")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("XPUB")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InternalWalletId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Keys");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.LiquidityRule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChannelId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsReverseSwapWalletRule")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal?>("MinimumLocalBalance")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal?>("MinimumRemoteBalance")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("NodeId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("RebalanceTarget")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ReverseSwapAddress")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ReverseSwapWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SwapWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId")
+                        .IsUnique();
+
+                    b.HasIndex("NodeId");
+
+                    b.HasIndex("ReverseSwapWalletId");
+
+                    b.HasIndex("SwapWalletId");
+
+                    b.ToTable("LiquidityRules");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Node", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("AllowPositiveInboundFees")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AutoLiquidityManagementEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AutoRebalanceEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AutosweepEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ChannelAdminMacaroon")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("DynamicFeeManagementEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Endpoint")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FortySwapEndpoint")
+                        .HasColumnType("text");
+
+                    b.Property<int>("FortySwapWeight")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("FundsDestinationWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsNodeDisabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("LoopSwapWeight")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LoopdCert")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoopdEndpoint")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoopdMacaroon")
+                        .HasColumnType("text");
+
+                    b.Property<double?>("MaxRebalanceCostToEarnRatio")
+                        .HasColumnType("double precision");
+
+                    b.Property<int?>("MaxRebalancesInFlight")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("MaxSwapRoutingFeeRatio")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("MaxSwapsInFlight")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("MinimumBalanceThresholdSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PubKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<TimeSpan?>("RebalanceBudgetRefreshInterval")
+                        .HasColumnType("interval");
+
+                    b.Property<long?>("RebalanceBudgetSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset?>("RebalanceBudgetStartDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("RoutingEngineDryRun")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<TimeSpan>("SwapBudgetRefreshInterval")
+                        .HasColumnType("interval");
+
+                    b.Property<long>("SwapBudgetSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset?>("SwapBudgetStartDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("SwapMaxAmountSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("SwapMinAmountSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FundsDestinationWalletId");
+
+                    b.HasIndex("PubKey")
+                        .IsUnique();
+
+                    b.ToTable("Nodes");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Rebalance", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<double?>("AmountBackoffRatio")
+                        .HasColumnType("double precision");
+
+                    b.Property<int>("AttemptNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("FeePaidMsat")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("FeePaidSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("IsManual")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("MaxAttempts")
+                        .HasColumnType("integer");
+
+                    b.Property<double>("MaxFeePct")
+                        .HasColumnType("double precision");
+
+                    b.Property<int>("NodeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PaymentHashHex")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentRequest")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PreimageHex")
+                        .HasColumnType("text");
+
+                    b.Property<long>("RequestedAmountSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<double?>("RetryMaxFeePct")
+                        .HasColumnType("double precision");
+
+                    b.Property<long>("SatsAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal?>("SourceChanIdLnd")
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<int?>("SourceChannelId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SourceNodePubKey")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TargetPubkey")
+                        .HasColumnType("text");
+
+                    b.Property<int>("TimeoutSeconds")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserRequestorId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NodeId");
+
+                    b.HasIndex("SourceChannelId");
+
+                    b.HasIndex("UserRequestorId");
+
+                    b.ToTable("Rebalances");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.SwapOut", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("DestinationWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ErrorDetails")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsManual")
+                        .HasColumnType("boolean");
+
+                    b.Property<long?>("LightningFeeSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<int?>("NodeId")
+                        .HasColumnType("integer");
+
+                    b.Property<long?>("OnChainFeeSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Provider")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("text");
+
+                    b.Property<long>("SatsAmount")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("ServiceFeeSats")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TxId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserRequestorId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DestinationWalletId");
+
+                    b.HasIndex("NodeId");
+
+                    b.HasIndex("UserRequestorId");
+
+                    b.ToTable("SwapOuts");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.UTXOTag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Outpoint")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key", "Outpoint")
+                        .IsUnique();
+
+                    b.ToTable("UTXOTags");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Wallet", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BIP39Seedphrase")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ImportedOutputDescriptor")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InternalWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("InternalWalletMasterFingerprint")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InternalWalletSubDerivationPath")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsBIP39Imported")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsCompromised")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsFinalised")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsHotWallet")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsUnSortedMultiSig")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MofN")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReferenceId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("WalletAddressType")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InternalWalletId");
+
+                    b.HasIndex("InternalWalletSubDerivationPath", "InternalWalletMasterFingerprint")
+                        .IsUnique();
+
+                    b.ToTable("Wallets");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.WalletWithdrawalRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("BumpingWalletWithdrawalRequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Changeless")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("CoinSelectionStrategy")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal?>("CustomFeeRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsRbfCancellation")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MempoolRecommendedFeesType")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RejectCancelDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestMetadata")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TxId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserRequestorId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("WalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("WithdrawAllFunds")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BumpingWalletWithdrawalRequestId");
+
+                    b.HasIndex("UserRequestorId");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("WalletWithdrawalRequests");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.WalletWithdrawalRequestDestination", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("WalletWithdrawalRequestId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WalletWithdrawalRequestId");
+
+                    b.ToTable("WalletWithdrawalRequestDestinations");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.WalletWithdrawalRequestPSBT", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsFinalisedPSBT")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInternalWalletPSBT")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsTemplatePSBT")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PSBT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SignerId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("WalletWithdrawalRequestId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SignerId");
+
+                    b.HasIndex("WalletWithdrawalRequestId");
+
+                    b.HasIndex(new[] { "WalletWithdrawalRequestId" }, "IX_WalletWithdrawalRequestPSBTs_Template")
+                        .IsUnique()
+                        .HasFilter("\"IsTemplatePSBT\"");
+
+                    b.ToTable("WalletWithdrawalRequestPSBTs");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ApplicationUser", b =>
+                {
+                    b.HasBaseType("Microsoft.AspNetCore.Identity.IdentityUser");
+
+                    b.HasDiscriminator().HasValue("ApplicationUser");
+                });
+
+            modelBuilder.Entity("ApplicationUserNode", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Node", null)
+                        .WithMany()
+                        .HasForeignKey("NodesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UsersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ChannelOperationRequestFMUTXO", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.ChannelOperationRequest", null)
+                        .WithMany()
+                        .HasForeignKey("ChannelOperationRequestsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.FMUTXO", null)
+                        .WithMany()
+                        .HasForeignKey("UtxosId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FMUTXOWalletWithdrawalRequest", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.FMUTXO", null)
+                        .WithMany()
+                        .HasForeignKey("UTXOsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.WalletWithdrawalRequest", null)
+                        .WithMany()
+                        .HasForeignKey("WalletWithdrawalRequestsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("KeyWallet", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Key", null)
+                        .WithMany()
+                        .HasForeignKey("KeysId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.Wallet", null)
+                        .WithMany()
+                        .HasForeignKey("WalletsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.APIToken", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Channel", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Node", "DestinationNode")
+                        .WithMany()
+                        .HasForeignKey("DestinationNodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.Node", "SourceNode")
+                        .WithMany()
+                        .HasForeignKey("SourceNodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DestinationNode");
+
+                    b.Navigation("SourceNode");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelFeeState", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Channel", "Channel")
+                        .WithMany()
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Channel");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelOperationRequest", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Channel", "Channel")
+                        .WithMany("ChannelOperationRequests")
+                        .HasForeignKey("ChannelId");
+
+                    b.HasOne("NodeGuard.Data.Models.Node", "DestNode")
+                        .WithMany("ChannelOperationRequestsAsDestination")
+                        .HasForeignKey("DestNodeId");
+
+                    b.HasOne("NodeGuard.Data.Models.Node", "SourceNode")
+                        .WithMany("ChannelOperationRequestsAsSource")
+                        .HasForeignKey("SourceNodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", "User")
+                        .WithMany("ChannelOperationRequests")
+                        .HasForeignKey("UserId");
+
+                    b.HasOne("NodeGuard.Data.Models.Wallet", "Wallet")
+                        .WithMany("ChannelOperationRequestsAsSource")
+                        .HasForeignKey("WalletId");
+
+                    b.Navigation("Channel");
+
+                    b.Navigation("DestNode");
+
+                    b.Navigation("SourceNode");
+
+                    b.Navigation("User");
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelOperationRequestPSBT", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.ChannelOperationRequest", "ChannelOperationRequest")
+                        .WithMany("ChannelOperationRequestPsbts")
+                        .HasForeignKey("ChannelOperationRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", "UserSigner")
+                        .WithMany()
+                        .HasForeignKey("UserSignerId");
+
+                    b.Navigation("ChannelOperationRequest");
+
+                    b.Navigation("UserSigner");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelRoutingState", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Channel", "Channel")
+                        .WithMany()
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Channel");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Key", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.InternalWallet", "InternalWallet")
+                        .WithMany()
+                        .HasForeignKey("InternalWalletId");
+
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", "User")
+                        .WithMany("Keys")
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("InternalWallet");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.LiquidityRule", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Channel", "Channel")
+                        .WithMany("LiquidityRules")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.Node", "Node")
+                        .WithMany()
+                        .HasForeignKey("NodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.Wallet", "ReverseSwapWallet")
+                        .WithMany("LiquidityRulesAsReverseSwapWallet")
+                        .HasForeignKey("ReverseSwapWalletId");
+
+                    b.HasOne("NodeGuard.Data.Models.Wallet", "SwapWallet")
+                        .WithMany("LiquidityRulesAsSwapWallet")
+                        .HasForeignKey("SwapWalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Channel");
+
+                    b.Navigation("Node");
+
+                    b.Navigation("ReverseSwapWallet");
+
+                    b.Navigation("SwapWallet");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Node", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Wallet", "FundsDestinationWallet")
+                        .WithMany()
+                        .HasForeignKey("FundsDestinationWalletId");
+
+                    b.Navigation("FundsDestinationWallet");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Rebalance", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Node", "Node")
+                        .WithMany()
+                        .HasForeignKey("NodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NodeGuard.Data.Models.Channel", "SourceChannel")
+                        .WithMany()
+                        .HasForeignKey("SourceChannelId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", "UserRequestor")
+                        .WithMany()
+                        .HasForeignKey("UserRequestorId");
+
+                    b.Navigation("Node");
+
+                    b.Navigation("SourceChannel");
+
+                    b.Navigation("UserRequestor");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.SwapOut", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.Wallet", "DestinationWallet")
+                        .WithMany("SwapOuts")
+                        .HasForeignKey("DestinationWalletId");
+
+                    b.HasOne("NodeGuard.Data.Models.Node", "Node")
+                        .WithMany("SwapOuts")
+                        .HasForeignKey("NodeId");
+
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", "UserRequestor")
+                        .WithMany()
+                        .HasForeignKey("UserRequestorId");
+
+                    b.Navigation("DestinationWallet");
+
+                    b.Navigation("Node");
+
+                    b.Navigation("UserRequestor");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Wallet", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.InternalWallet", "InternalWallet")
+                        .WithMany()
+                        .HasForeignKey("InternalWalletId");
+
+                    b.Navigation("InternalWallet");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.WalletWithdrawalRequest", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.WalletWithdrawalRequest", "BumpingWalletWithdrawalRequest")
+                        .WithMany()
+                        .HasForeignKey("BumpingWalletWithdrawalRequestId");
+
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", "UserRequestor")
+                        .WithMany("WalletWithdrawalRequests")
+                        .HasForeignKey("UserRequestorId");
+
+                    b.HasOne("NodeGuard.Data.Models.Wallet", "Wallet")
+                        .WithMany()
+                        .HasForeignKey("WalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BumpingWalletWithdrawalRequest");
+
+                    b.Navigation("UserRequestor");
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.WalletWithdrawalRequestDestination", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.WalletWithdrawalRequest", "WalletWithdrawalRequest")
+                        .WithMany("WalletWithdrawalRequestDestinations")
+                        .HasForeignKey("WalletWithdrawalRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WalletWithdrawalRequest");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.WalletWithdrawalRequestPSBT", b =>
+                {
+                    b.HasOne("NodeGuard.Data.Models.ApplicationUser", "Signer")
+                        .WithMany()
+                        .HasForeignKey("SignerId");
+
+                    b.HasOne("NodeGuard.Data.Models.WalletWithdrawalRequest", "WalletWithdrawalRequest")
+                        .WithMany("WalletWithdrawalRequestPSBTs")
+                        .HasForeignKey("WalletWithdrawalRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Signer");
+
+                    b.Navigation("WalletWithdrawalRequest");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Channel", b =>
+                {
+                    b.Navigation("ChannelOperationRequests");
+
+                    b.Navigation("LiquidityRules");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ChannelOperationRequest", b =>
+                {
+                    b.Navigation("ChannelOperationRequestPsbts");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Node", b =>
+                {
+                    b.Navigation("ChannelOperationRequestsAsDestination");
+
+                    b.Navigation("ChannelOperationRequestsAsSource");
+
+                    b.Navigation("SwapOuts");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Wallet", b =>
+                {
+                    b.Navigation("ChannelOperationRequestsAsSource");
+
+                    b.Navigation("LiquidityRulesAsReverseSwapWallet");
+
+                    b.Navigation("LiquidityRulesAsSwapWallet");
+
+                    b.Navigation("SwapOuts");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.WalletWithdrawalRequest", b =>
+                {
+                    b.Navigation("WalletWithdrawalRequestDestinations");
+
+                    b.Navigation("WalletWithdrawalRequestPSBTs");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.ApplicationUser", b =>
+                {
+                    b.Navigation("ChannelOperationRequests");
+
+                    b.Navigation("Keys");
+
+                    b.Navigation("WalletWithdrawalRequests");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Migrations/20260918121451_AddWithdrawalCoinSelectionStrategy.cs b/src/Migrations/20260918121451_AddWithdrawalCoinSelectionStrategy.cs
new file mode 100644
index 00000000..0db06961
--- /dev/null
+++ b/src/Migrations/20260918121451_AddWithdrawalCoinSelectionStrategy.cs
@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NodeGuard.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddWithdrawalCoinSelectionStrategy : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "CoinSelectionStrategy",
+                table: "WalletWithdrawalRequests",
+                type: "integer",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "CoinSelectionStrategy",
+                table: "WalletWithdrawalRequests");
+        }
+    }
+}
diff --git a/src/Migrations/ApplicationDbContextModelSnapshot.cs b/src/Migrations/ApplicationDbContextModelSnapshot.cs
index 484fbfc3..d50d75e4 100644
--- a/src/Migrations/ApplicationDbContextModelSnapshot.cs
+++ b/src/Migrations/ApplicationDbContextModelSnapshot.cs
@@ -1370,6 +1370,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<bool>("Changeless")
                         .HasColumnType("boolean");
 
+                    b.Property<int?>("CoinSelectionStrategy")
+                        .HasColumnType("integer");
+
                     b.Property<DateTimeOffset>("CreationDatetime")
                         .HasColumnType("timestamp with time zone");
 
diff --git a/src/Proto/nodeguard.proto b/src/Proto/nodeguard.proto
index b7fb3595..bd615b78 100644
--- a/src/Proto/nodeguard.proto
+++ b/src/Proto/nodeguard.proto
@@ -200,6 +200,8 @@ message RequestWithdrawalRequest {
   optional string reference_id = 10;
   // Destinations for the withdrawal
   repeated Destination destinations = 11;
+  // Optional coin selection strategy to be used by the withdrawal.
+  optional COIN_SELECTION_STRATEGY coin_selection_strategy = 12;
 }
 
 message RequestWithdrawalResponse {
diff --git a/src/Rpc/NodeGuardService.cs b/src/Rpc/NodeGuardService.cs
index 62130363..24a3085b 100644
--- a/src/Rpc/NodeGuardService.cs
+++ b/src/Rpc/NodeGuardService.cs
@@ -239,6 +239,23 @@ private void ValidateWithdrawalDestinations(IList<Destination> destinations, boo
         }
     }
 
+    /// <summary>
+    /// Maps the proto coin selection strategy onto the domain one. The two enums are kept in sync by hand, so
+    /// this switches on the members instead of casting the ordinal.
+    /// </summary>
+    private static CoinSelectionStrategy MapCoinSelectionStrategy(COIN_SELECTION_STRATEGY strategy)
+    {
+        return strategy switch
+        {
+            COIN_SELECTION_STRATEGY.SmallestFirst => CoinSelectionStrategy.SmallestFirst,
+            COIN_SELECTION_STRATEGY.BiggestFirst => CoinSelectionStrategy.BiggestFirst,
+            COIN_SELECTION_STRATEGY.ClosestToTargetFirst => CoinSelectionStrategy.ClosestToTargetFirst,
+            COIN_SELECTION_STRATEGY.UpToAmount => CoinSelectionStrategy.UpToAmount,
+            _ => throw new RpcException(new Status(StatusCode.InvalidArgument,
+                $"Unknown coin selection strategy: {strategy}"))
+        };
+    }
+
     public override async Task<RequestWithdrawalResponse> RequestWithdrawal(RequestWithdrawalRequest request,
         ServerCallContext context)
     {
@@ -295,7 +312,10 @@ public override async Task<RequestWithdrawalResponse> RequestWithdrawal(RequestW
                 Changeless = request.Changeless,
                 MempoolRecommendedFeesType = (MempoolRecommendedFeesType)request.MempoolFeeRate,
                 CustomFeeRate = request.CustomFeeRate,
-                ReferenceId = request.ReferenceId
+                ReferenceId = request.ReferenceId,
+                CoinSelectionStrategy = request.HasCoinSelectionStrategy
+                    ? MapCoinSelectionStrategy(request.CoinSelectionStrategy)
+                    : null
             };
 
             //Save withdrawal request
diff --git a/src/Services/BitcoinService.cs b/src/Services/BitcoinService.cs
index acb8bbcd..c0f44677 100644
--- a/src/Services/BitcoinService.cs
+++ b/src/Services/BitcoinService.cs
@@ -190,12 +190,19 @@ await _coinSelectionService.GetLockedUTXOsForRequest(walletWithdrawalRequest,
             }
 
 
-            var availableUTXOs = previouslyLockedUTXOs.Count > 0
+            var hasLockedUTXOs = previouslyLockedUTXOs.Count > 0;
+            var availableUTXOs = hasLockedUTXOs
                 ? previouslyLockedUTXOs
                 : await _coinSelectionService.GetAvailableUTXOsAsync(derivationStrategy);
+
+            // The strategy only applies while the selection is still open. Locked UTXOs are the inputs a
+            // changeless request picked or an RBF replacement has to reuse. A full withdrawal has already had
+            // its amount set to the whole balance above, from the plain listing, so re-selecting against that
+            // amount can only come up short.
+            var selectionIsOpen = !hasLockedUTXOs && !walletWithdrawalRequest.WithdrawAllFunds;
             var (scriptCoins, selectedUTXOs) =
                 await _coinSelectionService.GetTxInputCoins(availableUTXOs, walletWithdrawalRequest,
-                    derivationStrategy);
+                    derivationStrategy, selectionIsOpen ? walletWithdrawalRequest.CoinSelectionStrategy : null);
 
             if (scriptCoins == null || !scriptCoins.Any())
             {
diff --git a/src/Services/CoinSelectionService.cs b/src/Services/CoinSelectionService.cs
index f2188134..8b8efe84 100644
--- a/src/Services/CoinSelectionService.cs
+++ b/src/Services/CoinSelectionService.cs
@@ -73,10 +73,21 @@ public interface ICoinSelectionService
     /// </summary>
     public Task<List<string>> GetFrozenUTXOs();
 
+    /// <summary>
+    /// Picks the inputs to fund a request.
+    /// </summary>
+    /// <param name="availableUTXOs">The candidate set, used when no strategy is given.</param>
+    /// <param name="request"></param>
+    /// <param name="derivationStrategy"></param>
+    /// <param name="strategy">
+    /// When set, NBXplorer orders the UTXOs and <paramref name="availableUTXOs"/> is ignored. When null, the
+    /// oldest-first selection is applied to <paramref name="availableUTXOs"/>.
+    /// </param>
     public Task<(List<ICoin> coins, List<UTXO> selectedUTXOs)> GetTxInputCoins(
         List<UTXO> availableUTXOs,
         IBitcoinRequest request,
-        DerivationStrategyBase derivationStrategy);
+        DerivationStrategyBase derivationStrategy,
+        CoinSelectionStrategy? strategy = null);
 }
 
 public class CoinSelectionService: ICoinSelectionService
@@ -283,16 +294,62 @@ public async Task<List<UTXO>> GetAvailableUTXOsAsync(DerivationStrategyBase deri
     public async Task<(List<ICoin> coins, List<UTXO> selectedUTXOs)> GetTxInputCoins(
         List<UTXO> availableUTXOs,
         IBitcoinRequest request,
-        DerivationStrategyBase derivationStrategy)
+        DerivationStrategyBase derivationStrategy,
+        CoinSelectionStrategy? strategy = null)
     {
         var satsAmount = request.SatsAmount;
 
-        var selectedUTXOs = await LightningHelper.SelectUTXOsByOldest(request.Wallet, satsAmount, availableUTXOs, _logger);
+        List<UTXO> selectedUTXOs;
+        if (strategy.HasValue)
+        {
+            // NBXplorer does the ordering. If the custom backend is off or the call fails,
+            // GetAvailableUTXOsAsync degrades to the plain listing.
+            var orderedUTXOs =
+                await GetAvailableUTXOsAsync(derivationStrategy, strategy.Value, 0, satsAmount, satsAmount);
+            selectedUTXOs = TakeUntilAmountIsCovered(orderedUTXOs, satsAmount, request.Wallet.Id);
+        }
+        else
+        {
+            selectedUTXOs =
+                await LightningHelper.SelectUTXOsByOldest(request.Wallet, satsAmount, availableUTXOs, _logger);
+        }
+
         var coins = await LightningHelper.SelectCoins(request.Wallet, selectedUTXOs);
 
         return (coins, selectedUTXOs);
     }
 
+    /// <summary>
+    /// Takes UTXOs in the order they were given until the amount is covered, one UTXO past it so there is
+    /// room for the fee. Same accumulation as SelectUTXOsByOldest, only without the reordering, so the
+    /// order the caller asked for survives. An empty list means the set was short, which
+    /// GenerateTemplatePSBT turns into a NoUTXOsAvailableException.
+    /// </summary>
+    private List<UTXO> TakeUntilAmountIsCovered(List<UTXO> orderedUTXOs, long satsAmount, int walletId)
+    {
+        var selectedUTXOs = new List<UTXO>();
+
+        var totalSats = orderedUTXOs.Sum(x => ((Money)x.Value).Satoshi);
+        if (totalSats < satsAmount)
+        {
+            _logger.LogError(
+                "Error, the total UTXOs set balance for walletid: {WalletId} ({AvailableSats} sats) is less than the amount in the request ({RequestedSats} sats)",
+                walletId, totalSats, satsAmount);
+            return selectedUTXOs;
+        }
+
+        var accumulator = 0M;
+        foreach (var utxo in orderedUTXOs)
+        {
+            if (accumulator > satsAmount) break;
+
+            selectedUTXOs.Add(utxo);
+            accumulator += ((Money)utxo.Value).Satoshi;
+        }
+
+        return selectedUTXOs;
+    }
+
     public async Task<List<UTXO>> GetUTXOsByOutpointAsync(DerivationStrategyBase derivationStrategy, List<OutPoint> outPoints)
     {
         var utxos = await _nbXplorerService.GetUTXOsAsync(derivationStrategy);
diff --git a/src/Services/WithdrawalRequestService.cs b/src/Services/WithdrawalRequestService.cs
index 5491f291..686c9673 100644
--- a/src/Services/WithdrawalRequestService.cs
+++ b/src/Services/WithdrawalRequestService.cs
@@ -246,6 +246,7 @@ private async Task<WalletWithdrawalRequest> CreateReplacementAsync(int originalR
             RequestMetadata = original.RequestMetadata,
             // The replacement represents the same external request, so callers can keep tracking it by reference id.
             ReferenceId = original.ReferenceId,
+            CoinSelectionStrategy = original.CoinSelectionStrategy,
             BumpingWalletWithdrawalRequestId = original.Id,
             IsRbfCancellation = cancellation,
             WalletId = original.WalletId,
diff --git a/test/NodeGuard.Tests/Rpc/NodeGuardServiceTests.cs b/test/NodeGuard.Tests/Rpc/NodeGuardServiceTests.cs
index 65b7079e..d0e46102 100644
--- a/test/NodeGuard.Tests/Rpc/NodeGuardServiceTests.cs
+++ b/test/NodeGuard.Tests/Rpc/NodeGuardServiceTests.cs
@@ -669,6 +669,89 @@ public async Task RequestWithdrawal_Success()
             resp.Txid.Should().Be("f103e12f02ac1e5b8826831d4fc8fdb78a707bd00c4e1f191fe5d14458d63d5a");
         }
 
+        [Theory]
+        [InlineData(COIN_SELECTION_STRATEGY.SmallestFirst, CoinSelectionStrategy.SmallestFirst)]
+        [InlineData(COIN_SELECTION_STRATEGY.BiggestFirst, CoinSelectionStrategy.BiggestFirst)]
+        [InlineData(COIN_SELECTION_STRATEGY.ClosestToTargetFirst, CoinSelectionStrategy.ClosestToTargetFirst)]
+        [InlineData(COIN_SELECTION_STRATEGY.UpToAmount, CoinSelectionStrategy.UpToAmount)]
+        public async Task RequestWithdrawal_StoresTheRequestedCoinSelectionStrategy(
+            COIN_SELECTION_STRATEGY requested, CoinSelectionStrategy expected)
+        {
+            //Arrange
+            var wallet = InitMockRequestWithdrawal(out var walletRepository,
+                out var nbxplorerService,
+                out _,
+                out _,
+                out _,
+                out _,
+                out _,
+                out var bitcoinService,
+                out var walletWithdrawalRequestRepository,
+                out var mockScheduler);
+
+            // Cold wallet, so the request stops at the template PSBT instead of scheduling a PerformWithdrawalJob.
+            // Every fixture request has id 0, and the job key is the id, so the hot path collides across cases.
+            wallet.IsHotWallet = false;
+
+            var requestWithdrawalRequest = CreateWithdrawalRequest(wallet.Id, 100);
+            requestWithdrawalRequest.CoinSelectionStrategy = requested;
+
+            var mockNodeGuardService = CreateNodeGuardService(
+                walletRepository: walletRepository.Object,
+                walletWithdrawalRequestRepository: walletWithdrawalRequestRepository.Object,
+                bitcoinService: bitcoinService.Object,
+                nbXplorerService: nbxplorerService.Object,
+                schedulerFactory: mockScheduler);
+
+            //Act
+            await mockNodeGuardService.RequestWithdrawal(requestWithdrawalRequest, TestServerCallContext.Create());
+
+            //Assert
+            walletWithdrawalRequestRepository.Verify(
+                x => x.AddAsync(It.Is<WalletWithdrawalRequest>(r => r.CoinSelectionStrategy == expected)),
+                Times.Once);
+        }
+
+        /// <summary>
+        /// SmallestFirst is the proto zero value, so a request that omits the field must not be read as a request
+        /// for SmallestFirst. Null is what tells the selection to keep behaving as it does today.
+        /// </summary>
+        [Fact]
+        public async Task RequestWithdrawal_WithoutACoinSelectionStrategy_StoresNull()
+        {
+            //Arrange
+            var wallet = InitMockRequestWithdrawal(out var walletRepository,
+                out var nbxplorerService,
+                out _,
+                out _,
+                out _,
+                out _,
+                out _,
+                out var bitcoinService,
+                out var walletWithdrawalRequestRepository,
+                out var mockScheduler);
+
+            wallet.IsHotWallet = false;
+
+            var requestWithdrawalRequest = CreateWithdrawalRequest(wallet.Id, 100);
+
+            var mockNodeGuardService = CreateNodeGuardService(
+                walletRepository: walletRepository.Object,
+                walletWithdrawalRequestRepository: walletWithdrawalRequestRepository.Object,
+                bitcoinService: bitcoinService.Object,
+                nbXplorerService: nbxplorerService.Object,
+                schedulerFactory: mockScheduler);
+
+            //Act
+            await mockNodeGuardService.RequestWithdrawal(requestWithdrawalRequest, TestServerCallContext.Create());
+
+            //Assert
+            requestWithdrawalRequest.HasCoinSelectionStrategy.Should().BeFalse();
+            walletWithdrawalRequestRepository.Verify(
+                x => x.AddAsync(It.Is<WalletWithdrawalRequest>(r => r.CoinSelectionStrategy == null)),
+                Times.Once);
+        }
+
         [Fact]
         public async Task RequestWithdrawal_NoWallet()
         {
diff --git a/test/NodeGuard.Tests/Services/BitcoinServiceTests.cs b/test/NodeGuard.Tests/Services/BitcoinServiceTests.cs
index 719da7c8..7fe7d532 100644
--- a/test/NodeGuard.Tests/Services/BitcoinServiceTests.cs
+++ b/test/NodeGuard.Tests/Services/BitcoinServiceTests.cs
@@ -1929,4 +1929,112 @@ async Task GenerateTemplatePSBT_WithDuplicateTemplateRows_FailsLoudly()
         nbXplorerService.Verify(x => x.GetUTXOsAsync(It.IsAny<DerivationStrategyBase>(), default), Times.Never);
         psbtRepository.Verify(x => x.AddAsync(It.IsAny<WalletWithdrawalRequestPSBT>()), Times.Never);
     }
+
+    /// <summary>
+    /// Builds a request whose only interesting property is the coin selection strategy, runs
+    /// GenerateTemplatePSBT far enough to reach the selection, and hands back the strategy it was called with.
+    /// </summary>
+    private async Task<CoinSelectionStrategy?> CaptureSelectionStrategy(
+        CoinSelectionStrategy? requested, List<UTXO> lockedUTXOs, bool withdrawAllFunds = false)
+    {
+        var wallet = CreateWallet.SingleSig(_internalWallet);
+        var withdrawalRequest = new WalletWithdrawalRequest
+        {
+            Id = 1,
+            Status = WalletWithdrawalRequestStatus.Pending,
+            Wallet = wallet,
+            CoinSelectionStrategy = requested,
+            WithdrawAllFunds = withdrawAllFunds,
+            WalletWithdrawalRequestPSBTs = new List<WalletWithdrawalRequestPSBT>(),
+            WalletWithdrawalRequestDestinations = new List<WalletWithdrawalRequestDestination>
+            {
+                new() { Address = "bcrt1q590shaxaf5u08ml8jwlzghz99dup3z9592vxal", Amount = 0.01m }
+            }
+        };
+
+        var walletWithdrawalRequestRepository = new Mock<IWalletWithdrawalRequestRepository>();
+        walletWithdrawalRequestRepository.Setup(x => x.GetById(It.IsAny<int>())).ReturnsAsync(withdrawalRequest);
+
+        var nbXplorerService = new Mock<INBXplorerService>();
+        nbXplorerService.Setup(x => x.GetStatusAsync(default))
+            .ReturnsAsync(new StatusResult { IsFullySynched = true });
+
+        CoinSelectionStrategy? capturedStrategy = null;
+        var coinSelectionService = new Mock<ICoinSelectionService>();
+        coinSelectionService
+            .Setup(x => x.GetLockedUTXOsForRequest(It.IsAny<IBitcoinRequest>(), BitcoinRequestType.WalletWithdrawal))
+            .ReturnsAsync(lockedUTXOs);
+        coinSelectionService
+            .Setup(x => x.GetAvailableUTXOsAsync(It.IsAny<DerivationStrategyBase>()))
+            .ReturnsAsync(new List<UTXO>());
+        coinSelectionService
+            .Setup(x => x.GetTxInputCoins(It.IsAny<List<UTXO>>(), It.IsAny<IBitcoinRequest>(),
+                It.IsAny<DerivationStrategyBase>(), It.IsAny<CoinSelectionStrategy?>()))
+            .Callback<List<UTXO>, IBitcoinRequest, DerivationStrategyBase, CoinSelectionStrategy?>(
+                (_, _, _, strategy) => capturedStrategy = strategy)
+            // An empty selection stops GenerateTemplatePSBT right after the call we are watching
+            .ReturnsAsync((new List<ICoin>(), new List<UTXO>()));
+
+        var bitcoinService = new BitcoinService(_logger, null, walletWithdrawalRequestRepository.Object,
+            new Mock<IWalletWithdrawalRequestPsbtRepository>().Object, null, null, nbXplorerService.Object,
+            coinSelectionService.Object);
+
+        await bitcoinService.Invoking(x => x.GenerateTemplatePSBT(withdrawalRequest))
+            .Should().ThrowAsync<NoUTXOsAvailableException>();
+
+        return capturedStrategy;
+    }
+
+    [Fact]
+    async Task GenerateTemplatePSBT_PassesTheRequestedCoinSelectionStrategy()
+    {
+        var strategy = await CaptureSelectionStrategy(CoinSelectionStrategy.BiggestFirst, new List<UTXO>());
+
+        strategy.Should().Be(CoinSelectionStrategy.BiggestFirst);
+    }
+
+    /// <summary>
+    /// Locked UTXOs are the inputs a changeless request picked or an RBF replacement has to reuse. Applying a
+    /// strategy there would re-select the inputs, so the replacement would no longer replace anything.
+    /// </summary>
+    [Fact]
+    async Task GenerateTemplatePSBT_WithLockedUTXOs_IgnoresTheCoinSelectionStrategy()
+    {
+        var wallet = CreateWallet.SingleSig(_internalWallet);
+        var lockedUTXO = new UTXO
+        {
+            Outpoint = new OutPoint(new uint256(1), 0),
+            Value = new Money(100_000L),
+            KeyPath = KeyPath.Parse("0/0"),
+            ScriptPubKey = (wallet.GetDerivationStrategy() as StandardDerivationStrategyBase)!
+                .GetDerivation(KeyPath.Parse("0/0")).ScriptPubKey
+        };
+
+        var strategy = await CaptureSelectionStrategy(CoinSelectionStrategy.BiggestFirst,
+            new List<UTXO> { lockedUTXO });
+
+        strategy.Should().BeNull();
+    }
+
+    /// <summary>A request that picked no strategy must reach the selection unchanged.</summary>
+    [Fact]
+    async Task GenerateTemplatePSBT_WithoutACoinSelectionStrategy_PassesNull()
+    {
+        var strategy = await CaptureSelectionStrategy(null, new List<UTXO>());
+
+        strategy.Should().BeNull();
+    }
+
+    /// <summary>
+    /// A full withdrawal has its amount set to the whole available balance before the selection runs, so
+    /// re-selecting against that amount could only come up short.
+    /// </summary>
+    [Fact]
+    async Task GenerateTemplatePSBT_WithdrawAllFunds_IgnoresTheCoinSelectionStrategy()
+    {
+        var strategy = await CaptureSelectionStrategy(CoinSelectionStrategy.BiggestFirst, new List<UTXO>(),
+            withdrawAllFunds: true);
+
+        strategy.Should().BeNull();
+    }
 }
diff --git a/test/NodeGuard.Tests/Services/CoinSelectionServiceTests.cs b/test/NodeGuard.Tests/Services/CoinSelectionServiceTests.cs
index f72b184f..a5c03790 100644
--- a/test/NodeGuard.Tests/Services/CoinSelectionServiceTests.cs
+++ b/test/NodeGuard.Tests/Services/CoinSelectionServiceTests.cs
@@ -438,4 +438,171 @@ public async Task GetAvailableUTXOsAsync_ExcludesDustAndLockedUTXOs()
         availableUTXOs.Should().ContainSingle();
         availableUTXOs[0].Outpoint.Should().Be(availableUtxo.Outpoint);
     }
+
+    /// <summary>A UTXO complete enough for LightningHelper.SelectCoins to turn it into a coin.</summary>
+    private static UTXO CreateSpendableUtxo(Wallet wallet, uint index, long satoshis, int confirmations = 1)
+    {
+        var keyPath = KeyPath.Parse($"0/{index}");
+
+        return new UTXO
+        {
+            Outpoint = new OutPoint(new uint256(index), 0),
+            Value = new Money(satoshis),
+            Confirmations = confirmations,
+            KeyPath = keyPath,
+            ScriptPubKey = (wallet.GetDerivationStrategy() as StandardDerivationStrategyBase)!
+                .GetDerivation(keyPath).ScriptPubKey
+        };
+    }
+
+    private static WalletWithdrawalRequest CreateRequest(Wallet wallet, decimal amountBtc)
+    {
+        return new WalletWithdrawalRequest
+        {
+            Id = 1,
+            Wallet = wallet,
+            WalletWithdrawalRequestDestinations = new List<WalletWithdrawalRequestDestination>
+            {
+                new() { Address = "bcrt1q590shaxaf5u08ml8jwlzghz99dup3z9592vxal", Amount = amountBtc }
+            }
+        };
+    }
+
+    [Fact]
+    public async Task GetTxInputCoins_WithStrategy_SelectsInTheOrderNBXplorerReturns()
+    {
+        var previousCustomBackend = Constants.NBXPLORER_ENABLE_CUSTOM_BACKEND;
+        Constants.NBXPLORER_ENABLE_CUSTOM_BACKEND = true;
+        try
+        {
+            // Arrange
+            var wallet = CreateWallet.SingleSig(_internalWallet);
+            var derivationStrategy = wallet.GetDerivationStrategy();
+
+            // SelectUTXOsByOldest pops in ascending confirmations, so it would take the 100k UTXO on its
+            // own. Following NBXplorer's order instead takes the two small ones.
+            var small = CreateSpendableUtxo(wallet, 1, 6_000, confirmations: 2);
+            var smaller = CreateSpendableUtxo(wallet, 2, 5_000, confirmations: 3);
+            var big = CreateSpendableUtxo(wallet, 3, 100_000, confirmations: 1);
+
+            var fmutxoRepository = new Mock<IFMUTXORepository>();
+            fmutxoRepository.Setup(x => x.GetLockedUTXOs(null, null)).ReturnsAsync(new List<FMUTXO>());
+
+            var utxoTagRepository = new Mock<IUTXOTagRepository>();
+            utxoTagRepository.Setup(x => x.GetByKeyValue(It.IsAny<string>(), It.IsAny<string>()))
+                .ReturnsAsync(new List<UTXOTag>());
+
+            var nbXplorerService = new Mock<INBXplorerService>();
+            nbXplorerService
+                .Setup(x => x.GetUTXOsAsync(It.IsAny<DerivationStrategyBase>(), default))
+                .ReturnsAsync(new UTXOChanges
+                {
+                    Confirmed = new UTXOChange { UTXOs = new List<UTXO> { small, smaller, big } }
+                });
+            nbXplorerService
+                .Setup(x => x.GetUTXOsByLimitAsync(It.IsAny<DerivationStrategyBase>(),
+                    It.IsAny<CoinSelectionStrategy>(), It.IsAny<int>(), It.IsAny<long>(), It.IsAny<long>(),
+                    It.IsAny<List<string>>(), default))
+                .ReturnsAsync(new UTXOChanges
+                {
+                    Confirmed = new UTXOChange { UTXOs = new List<UTXO> { small, smaller, big } }
+                });
+
+            var coinSelectionService = new CoinSelectionService(_logger, new Mock<IMapper>().Object,
+                fmutxoRepository.Object, nbXplorerService.Object, null, null, utxoTagRepository.Object);
+
+            var request = CreateRequest(wallet, 0.0001m); // 10_000 sats
+
+            // Act
+            var (coins, selectedUTXOs) = await coinSelectionService.GetTxInputCoins(
+                new List<UTXO>(), request, derivationStrategy, CoinSelectionStrategy.SmallestFirst);
+
+            // Assert
+            nbXplorerService.Verify(x => x.GetUTXOsByLimitAsync(derivationStrategy,
+                CoinSelectionStrategy.SmallestFirst, 0, 10_000, 10_000, It.IsAny<List<string>>(), default),
+                Times.Once);
+            selectedUTXOs.Select(x => x.Outpoint).Should()
+                .Equal(new[] { small.Outpoint, smaller.Outpoint }, "the order NBXplorer returned is kept");
+            coins.Should().HaveCount(2);
+        }
+        finally
+        {
+            Constants.NBXPLORER_ENABLE_CUSTOM_BACKEND = previousCustomBackend;
+        }
+    }
+
+    [Fact]
+    public async Task GetTxInputCoins_WithoutStrategy_KeepsTheOldestFirstSelection()
+    {
+        // Arrange
+        var wallet = CreateWallet.SingleSig(_internalWallet);
+        var derivationStrategy = wallet.GetDerivationStrategy();
+        var utxo = CreateSpendableUtxo(wallet, 1, 100_000);
+
+        var nbXplorerService = new Mock<INBXplorerService>();
+        var coinSelectionService = new CoinSelectionService(_logger, new Mock<IMapper>().Object,
+            new Mock<IFMUTXORepository>().Object, nbXplorerService.Object, null, null,
+            new Mock<IUTXOTagRepository>().Object);
+
+        var request = CreateRequest(wallet, 0.0001m); // 10_000 sats
+
+        // Act
+        var (coins, selectedUTXOs) = await coinSelectionService.GetTxInputCoins(
+            new List<UTXO> { utxo }, request, derivationStrategy);
+
+        // Assert
+        selectedUTXOs.Should().ContainSingle().Which.Outpoint.Should().Be(utxo.Outpoint);
+        coins.Should().ContainSingle();
+        nbXplorerService.Verify(x => x.GetUTXOsByLimitAsync(It.IsAny<DerivationStrategyBase>(),
+            It.IsAny<CoinSelectionStrategy>(), It.IsAny<int>(), It.IsAny<long>(), It.IsAny<long>(),
+            It.IsAny<List<string>>(), default), Times.Never);
+    }
+
+    [Fact]
+    public async Task GetTxInputCoins_WithStrategy_ReturnsNothingWhenTheSetIsShort()
+    {
+        var previousCustomBackend = Constants.NBXPLORER_ENABLE_CUSTOM_BACKEND;
+        Constants.NBXPLORER_ENABLE_CUSTOM_BACKEND = true;
+        try
+        {
+            // Arrange
+            var wallet = CreateWallet.SingleSig(_internalWallet);
+            var derivationStrategy = wallet.GetDerivationStrategy();
+            var utxo = CreateSpendableUtxo(wallet, 1, 1_000);
+
+            var fmutxoRepository = new Mock<IFMUTXORepository>();
+            fmutxoRepository.Setup(x => x.GetLockedUTXOs(null, null)).ReturnsAsync(new List<FMUTXO>());
+
+            var utxoTagRepository = new Mock<IUTXOTagRepository>();
+            utxoTagRepository.Setup(x => x.GetByKeyValue(It.IsAny<string>(), It.IsAny<string>()))
+                .ReturnsAsync(new List<UTXOTag>());
+
+            var nbXplorerService = new Mock<INBXplorerService>();
+            nbXplorerService
+                .Setup(x => x.GetUTXOsAsync(It.IsAny<DerivationStrategyBase>(), default))
+                .ReturnsAsync(new UTXOChanges { Confirmed = new UTXOChange { UTXOs = new List<UTXO> { utxo } } });
+            nbXplorerService
+                .Setup(x => x.GetUTXOsByLimitAsync(It.IsAny<DerivationStrategyBase>(),
+                    It.IsAny<CoinSelectionStrategy>(), It.IsAny<int>(), It.IsAny<long>(), It.IsAny<long>(),
+                    It.IsAny<List<string>>(), default))
+                .ReturnsAsync(new UTXOChanges { Confirmed = new UTXOChange { UTXOs = new List<UTXO> { utxo } } });
+
+            var coinSelectionService = new CoinSelectionService(_logger, new Mock<IMapper>().Object,
+                fmutxoRepository.Object, nbXplorerService.Object, null, null, utxoTagRepository.Object);
+
+            var request = CreateRequest(wallet, 0.0001m); // 10_000 sats, more than the wallet holds
+
+            // Act
+            var (coins, selectedUTXOs) = await coinSelectionService.GetTxInputCoins(
+                new List<UTXO>(), request, derivationStrategy, CoinSelectionStrategy.BiggestFirst);
+
+            // Assert: GenerateTemplatePSBT turns an empty selection into NoUTXOsAvailableException
+            selectedUTXOs.Should().BeEmpty();
+            coins.Should().BeEmpty();
+        }
+        finally
+        {
+            Constants.NBXPLORER_ENABLE_CUSTOM_BACKEND = previousCustomBackend;
+        }
+    }
 }
diff --git a/test/NodeGuard.Tests/Services/WithdrawalRequestServiceTests.cs b/test/NodeGuard.Tests/Services/WithdrawalRequestServiceTests.cs
index 612d0743..80448162 100644
--- a/test/NodeGuard.Tests/Services/WithdrawalRequestServiceTests.cs
+++ b/test/NodeGuard.Tests/Services/WithdrawalRequestServiceTests.cs
@@ -126,6 +126,32 @@ public async Task CreateBumpRequestAsync_HotWallet_CreatesTheBumpInPsbtSignature
             BitcoinRequestType.WalletWithdrawal), Times.Once);
     }
 
+    /// <summary>
+    /// The replacement stands in for the same original request, so it keeps the requested coin selection strategy
+    /// the way it keeps RequestMetadata and ReferenceId. Nothing reads the field yet.
+    /// </summary>
+    [Fact]
+    public async Task CreateBumpRequestAsync_CarriesTheCoinSelectionStrategyOfTheOriginal()
+    {
+        var original = SetupOriginal(HotWallet());
+        original.CoinSelectionStrategy = CoinSelectionStrategy.BiggestFirst;
+
+        var bump = await CreateService().CreateBumpRequestAsync(OriginalId, MempoolRecommendedFeesType.CustomFee, 10m);
+
+        bump.CoinSelectionStrategy.Should().Be(CoinSelectionStrategy.BiggestFirst);
+    }
+
+    [Fact]
+    public async Task CreateCancelRequestAsync_CarriesTheCoinSelectionStrategyOfTheOriginal()
+    {
+        var original = SetupOriginal(HotWallet());
+        original.CoinSelectionStrategy = CoinSelectionStrategy.ClosestToTargetFirst;
+
+        var cancel = await CreateService().CreateCancelRequestAsync(OriginalId, MempoolRecommendedFeesType.CustomFee, 10m);
+
+        cancel.CoinSelectionStrategy.Should().Be(CoinSelectionStrategy.ClosestToTargetFirst);
+    }
+
     [Fact]
     public async Task CreateBumpRequestAsync_ColdWallet_CreatesTheBumpPendingForApprovers()
     {