diff --git a/src/Data/Models/Node.cs b/src/Data/Models/Node.cs
index c42f68ba..2a8ae58d 100644
--- a/src/Data/Models/Node.cs
+++ b/src/Data/Models/Node.cs
@@ -51,6 +51,11 @@ public class Node : Entity
 
         public Wallet? ReturningFundsWallet { get; set; }
 
+        /// <summary>
+        /// enable/disable node
+        /// </summary>
+        public bool IsNodeDisabled { get; set; }
+
         /// <summary>
         /// Returns true if the node is managed by us. We defer this from the existence of an Endpoint
         /// </summary>
diff --git a/src/Data/Repositories/NodeRepository.cs b/src/Data/Repositories/NodeRepository.cs
index 0c20bc2c..66b24c45 100644
--- a/src/Data/Repositories/NodeRepository.cs
+++ b/src/Data/Repositories/NodeRepository.cs
@@ -67,6 +67,7 @@ public NodeRepository(IRepository<Node> repository,
                 .Include(x => x.ReturningFundsWallet)
                 .SingleOrDefaultAsync(x => x.PubKey == key);
         }
+        
 
         public async Task<Node> GetOrCreateByPubKey(string pubKey, ILightningService lightningService)
         {
@@ -113,15 +114,17 @@ public async Task<List<Node>> GetAllManagedByNodeGuard()
         {
             await using var applicationDbContext = await _dbContextFactory.CreateDbContextAsync();
 
-            var resultAsync = await applicationDbContext.Nodes
+            var query = applicationDbContext.Nodes
                 .Include(x => x.ReturningFundsWallet)
                 .ThenInclude(x => x.Keys)
-                .Where(node => node.Endpoint != null)
-                .ToListAsync();
+                .Include(x => x.ReturningFundsWallet)
+                .Where(node => node.Endpoint != null);
+
+            var resultAsync = await query.ToListAsync();
 
             return resultAsync;
         }
-
+        
         public async Task<List<Node>> GetAllManagedByUser(string userId)
         {
             await using var applicationDbContext = await _dbContextFactory.CreateDbContextAsync();
diff --git a/src/Helpers/JobTypes.cs b/src/Helpers/JobTypes.cs
index 9fb3d026..ebe93881 100644
--- a/src/Helpers/JobTypes.cs
+++ b/src/Helpers/JobTypes.cs
@@ -18,6 +18,8 @@
  */
 
 using Quartz;
+using Quartz.Impl;
+using Quartz.Impl.Matchers;
 using Quartz.Impl.Triggers;
 
 namespace NodeGuard.Helpers;
@@ -33,9 +35,9 @@ public class SimpleJob
     public static JobAndTrigger Create<T>(JobDataMap data, string identitySuffix) where T : IJob
     {
         var job = JobBuilder.Create<T>()
-                    .WithIdentity($"{typeof(T).Name}-{identitySuffix}")
-                    .SetJobData(data ?? new JobDataMap())
-                    .Build();
+            .WithIdentity($"{typeof(T).Name}-{identitySuffix}")
+            .SetJobData(data ?? new JobDataMap())
+            .Build();
 
         var trigger = TriggerBuilder.Create()
             .WithIdentity($"{typeof(T).Name}Trigger-{identitySuffix}")
@@ -44,6 +46,46 @@ public static JobAndTrigger Create<T>(JobDataMap data, string identitySuffix) wh
 
         return new JobAndTrigger(job, trigger);
     }
+    
+    public static async Task Reschedule<T>(IScheduler scheduler, string identitySuffix) where T : IJob
+    {
+        try
+        {
+            var triggerKey = new TriggerKey($"{typeof(T).Name}-{identitySuffix}");
+
+            var trigger = TriggerBuilder.Create()
+                .WithIdentity($"{typeof(T).Name}Trigger-{identitySuffix}")
+                .StartNow()
+                .Build();
+            
+            await scheduler.RescheduleJob(triggerKey, trigger);
+
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Unexpected error rescheduling job of type {typeof(T).Name} with identity suffix {identitySuffix}: {ex.Message}");
+        }
+    }
+    
+    public static async Task DeleteJob<T>(IScheduler scheduler, string identitySuffix) where T : IJob
+    {
+        try
+        {
+            JobKey jobKey = new JobKey($"{typeof(T).Name}-{identitySuffix}");
+            await scheduler.DeleteJob(jobKey);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Unexpected error occurred while removing the job of type {typeof(T).Name} with identity suffix {identitySuffix}: {ex.Message}");
+        }
+    }
+
+    public static async Task<bool> IsJobExists<T>(IScheduler scheduler, string identitySuffix) where T : IJob
+    {
+        JobKey jobKey = new JobKey($"{typeof(T).Name}-{identitySuffix}");
+        return await scheduler.CheckExists(jobKey);
+    }
+    
 }
 
 public class RetriableJob
@@ -55,7 +97,8 @@ public class RetriableJob
     /// <param name="identitySuffix">A suffix to identify a specific job, triggered from the same class</param>
     /// <param name="intervalListInMinutes">An optional list of retry intervals in minutes, defaults to { 1, 5, 10, 20 }</param>
     /// <returns>An object with a job and a trigger to pass to a scheduler</returns>
-    public static JobAndTrigger Create<T>(JobDataMap data, string identitySuffix, int[]? intervalListInMinutes = null) where T : IJob
+    public static JobAndTrigger Create<T>(JobDataMap data, string identitySuffix, int[]? intervalListInMinutes = null)
+        where T : IJob
     {
         intervalListInMinutes = intervalListInMinutes ?? new int[] { 1, 5, 10, 20 };
 
@@ -63,10 +106,10 @@ public static JobAndTrigger Create<T>(JobDataMap data, string identitySuffix, in
         map.Put("intervalListInMinutes", intervalListInMinutes);
 
         var job = JobBuilder.Create<T>()
-                   .DisallowConcurrentExecution()
-                   .SetJobData(map)
-                   .WithIdentity($"{typeof(T).Name}-{identitySuffix}")
-                   .Build();
+            .DisallowConcurrentExecution()
+            .SetJobData(map)
+            .WithIdentity($"{typeof(T).Name}-{identitySuffix}")
+            .Build();
 
         var trigger = TriggerBuilder.Create()
             .WithIdentity($"{typeof(T).Name}Trigger-{identitySuffix}")
@@ -103,7 +146,7 @@ public static async Task Execute(IJobExecutionContext context, Func<Task> callba
         if (intervals == null)
         {
             throw new Exception("No interval list found, make sure you're using the RetriableJob class");
-        };
+        }
 
         var trigger = context.Trigger as SimpleTriggerImpl;
 
@@ -134,7 +177,7 @@ public static async Task OnFail(IJobExecutionContext context, Func<Task> callbac
         if (intervals == null)
         {
             throw new Exception("No interval list found, make sure you're using the RetriableJob class");
-        };
+        }
 
         var trigger = context.Trigger as SimpleTriggerImpl;
 
@@ -144,7 +187,7 @@ public static async Task OnFail(IJobExecutionContext context, Func<Task> callbac
             await callback();
         }
     }
-    
+
     /// <summary>
     /// Get the next interval time
     /// </summary>
@@ -156,7 +199,7 @@ public static async Task OnFail(IJobExecutionContext context, Func<Task> callbac
         if (intervals == null)
         {
             throw new Exception("No interval list found, make sure you're using the RetriableJob class");
-        };
+        }
 
         var trigger = context.Trigger as SimpleTriggerImpl;
 
@@ -166,7 +209,7 @@ public static async Task OnFail(IJobExecutionContext context, Func<Task> callbac
         }
 
         return null;
-    } 
+    }
 }
 
 public class JobAndTrigger
@@ -180,10 +223,12 @@ public JobAndTrigger(IJobDetail job, ITrigger trigger)
         {
             throw new Exception("Job parameter is needed");
         }
+
         if (trigger == null)
         {
             throw new Exception("Trigger parameter is needed");
         }
+
         Job = job;
         Trigger = trigger;
     }
diff --git a/src/Migrations/20231205153253_IsNodeDisabled.Designer.cs b/src/Migrations/20231205153253_IsNodeDisabled.Designer.cs
new file mode 100644
index 00000000..0790f82a
--- /dev/null
+++ b/src/Migrations/20231205153253_IsNodeDisabled.Designer.cs
@@ -0,0 +1,1263 @@
+// <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("20231205153253_IsNodeDisabled")]
+    partial class IsNodeDisabled
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "7.0.14")
+                .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()
+                        .HasColumnType("text");
+
+                    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<string>("Discriminator").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.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<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>("IsAutomatedLiquidityEnabled")
+                        .HasColumnType("boolean");
+
+                    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.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<bool>("IsChannelPrivate")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MempoolRecommendedFeesTypes")
+                        .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.ToTable("ChannelOperationRequestPSBTs");
+                });
+
+            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.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>("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<string>("Endpoint")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsNodeDisabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JobId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PubKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ReturningFundsWalletId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdateDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PubKey")
+                        .IsUnique();
+
+                    b.HasIndex("ReturningFundsWalletId");
+
+                    b.ToTable("Nodes");
+                });
+
+            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<decimal>("Amount")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool>("Changeless")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("CreationDatetime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DestinationAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("JobId")
+                        .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("UserRequestorId");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("WalletWithdrawalRequests");
+                });
+
+            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.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.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.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", "ReturningFundsWallet")
+                        .WithMany()
+                        .HasForeignKey("ReturningFundsWalletId");
+
+                    b.Navigation("ReturningFundsWallet");
+                });
+
+            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.ApplicationUser", "UserRequestor")
+                        .WithMany("WalletWithdrawalRequests")
+                        .HasForeignKey("UserRequestorId");
+
+                    b.HasOne("NodeGuard.Data.Models.Wallet", "Wallet")
+                        .WithMany()
+                        .HasForeignKey("WalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UserRequestor");
+
+                    b.Navigation("Wallet");
+                });
+
+            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");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.Wallet", b =>
+                {
+                    b.Navigation("ChannelOperationRequestsAsSource");
+
+                    b.Navigation("LiquidityRulesAsReverseSwapWallet");
+
+                    b.Navigation("LiquidityRulesAsSwapWallet");
+                });
+
+            modelBuilder.Entity("NodeGuard.Data.Models.WalletWithdrawalRequest", b =>
+                {
+                    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/20231205153253_IsNodeDisabled.cs b/src/Migrations/20231205153253_IsNodeDisabled.cs
new file mode 100644
index 00000000..caf65b97
--- /dev/null
+++ b/src/Migrations/20231205153253_IsNodeDisabled.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NodeGuard.Migrations
+{
+    /// <inheritdoc />
+    public partial class IsNodeDisabled : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsNodeDisabled",
+                table: "Nodes",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsNodeDisabled",
+                table: "Nodes");
+        }
+    }
+}
diff --git a/src/Migrations/ApplicationDbContextModelSnapshot.cs b/src/Migrations/ApplicationDbContextModelSnapshot.cs
index 487c3bc1..73a9f9a9 100644
--- a/src/Migrations/ApplicationDbContextModelSnapshot.cs
+++ b/src/Migrations/ApplicationDbContextModelSnapshot.cs
@@ -19,7 +19,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "7.0.9")
+                .HasAnnotation("ProductVersion", "7.0.14")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
@@ -707,6 +707,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("Endpoint")
                         .HasColumnType("text");
 
+                    b.Property<bool>("IsNodeDisabled")
+                        .HasColumnType("boolean");
+
                     b.Property<string>("JobId")
                         .HasColumnType("text");
 
diff --git a/src/Pages/Nodes.razor b/src/Pages/Nodes.razor
index 4d1fcf35..5b5095c2 100644
--- a/src/Pages/Nodes.razor
+++ b/src/Pages/Nodes.razor
@@ -27,16 +27,24 @@
                 <h2>@(context.EditState) node</h2>
             </PopupTitleTemplate>
             <DataGridColumns>
-                <DataGridCommandColumn TItem="Node" Filterable="false" Width="120px">
+    
+                <DataGridCommandColumn TItem="Node" Filterable="false"  Editable="false" Width="60px">
+
+                    <EditCommandTemplate>
+                        <Dropdown @onclick:stopPropagation="true">
+                            <DropdownToggle Color="Color.Primary">
+                            </DropdownToggle>
+                            <DropdownMenu>
+                                <DropdownItem Clicked="context.Clicked">Edit</DropdownItem>
+                                <DropdownItem Clicked="@(() => ShowDeleteDialog(context.Item))">Delete</DropdownItem>
+                                <DropdownItem Clicked="@(() => ToggleNodeStatus(context.Item))">@_NodesState(context.Item)</DropdownItem>
+                            </DropdownMenu>
+                        </Dropdown>
+                    </EditCommandTemplate>
+                    <DeleteCommandTemplate/>
                     <NewCommandTemplate>
                         <Button Color="Color.Success" TextColor="TextColor.Light" Clicked="@context.Clicked" Block>New</Button>
                     </NewCommandTemplate>
-                    <EditCommandTemplate>
-                        <Button Color="Color.Primary" Clicked="@context.Clicked" Size="Size.Small" Block>Edit</Button>
-                    </EditCommandTemplate>
-                    <DeleteCommandTemplate>
-                        <Button Color="Color.Danger" hidden="@_hideDelete" Clicked="@(()=> ShowDeleteDialog(context.Item))" Size="Size.Small" Block>Delete</Button>
-                    </DeleteCommandTemplate>
                 </DataGridCommandColumn>
                 <DataGridColumn TItem="Node" Filterable="false" Editable="true" Field="@nameof(Node.Name)" Validator="ValidationHelper.ValidateName" Caption="@nameof(Node.Name)" Sortable="false" Displayable="@IsColumnVisible(NodesColumnName.Name)"/>
                 <DataGridColumn TItem="Node" Filterable="false" Editable="true" Field="@nameof(Node.PubKey)" Caption="@nameof(Node.PubKey)" Sortable="false" Width="220px" Displayable="@IsColumnVisible(NodesColumnName.PubKey)">
@@ -102,6 +110,7 @@
 
                     </EditTemplate>
                 </DataGridColumn>
+                <DataGridColumn TItem="Node" Filterable="false" Editable="false" Field="@nameof(Node.IsNodeDisabled)" Caption="Disabled" Sortable="false" Displayable="@IsColumnVisible(NodesColumnName.Disabled)"></DataGridColumn>
                 <DataGridColumn TItem="Node" Filterable="false" Editable="true" Field="@nameof(Node.AutosweepEnabled)" Caption="Autosweep" Sortable="false" Displayable="@IsColumnVisible(NodesColumnName.Autosweep)"></DataGridColumn>
                 <DataGridColumn TItem="Node" Filterable="false" Field="@nameof(Node.CreationDatetime)" Caption="Creation Date" Sortable="true" SortDirection="SortDirection.Descending" Displayable="@IsColumnVisible(NodesColumnName.CreationDate)">
                     <DisplayTemplate>
@@ -161,7 +170,7 @@
     private bool _modalVisible;
     private bool _hideDelete = true;
     private bool _editable;
-    private List<Wallet> _availableWallets = new List<Wallet>();
+    private List<Wallet> _availableWallets = new();
 
     CancellationTokenSource cts = new();
 
@@ -183,6 +192,7 @@
         public static readonly ColumnDefault Endpoint = new("Endpoint");
         public static readonly ColumnDefault OutboundOpenChannels = new("Outbound Open Channels");
         public static readonly ColumnDefault ReturningFundsWallet = new("Returning Funds Wallet");
+        public static readonly ColumnDefault Disabled = new("Disabled");
         public static readonly ColumnDefault Autosweep = new("Autosweep");
         public static readonly ColumnDefault CreationDate = new("Creation Date");
         public static readonly ColumnDefault UpdateDate = new("Update Date");
@@ -204,6 +214,45 @@
             }
         }
     }
+    
+    private string _NodesState(Node node)
+    {
+        return node.IsNodeDisabled ?  "Enable Node" : "Disable Node";
+    }
+    
+    private async Task ToggleNodeStatus(Node node)
+    {
+        try
+        {
+            node.IsNodeDisabled = !node.IsNodeDisabled;
+            if (node.IsNodeDisabled)
+            {
+                await StopJob(node);
+            }
+            else
+            {
+                await CreateJobs(node);
+            }
+            node.JobId = null;
+            var (result, _) = NodeRepository.Update(node);
+            if (result)
+            {
+                _nodes = await NodeRepository.GetAllManagedByNodeGuard();
+                _availableWallets = await WalletRepository.GetAvailableWallets();
+                string status = node.IsNodeDisabled ? "disabled": "enabled";
+                string message = $"{node.Name} is {status}";
+                ToastService.ShowSuccess(message);
+            }
+            else
+            {
+                ToastService.ShowError($"Error while disabling the {node.Name}, please contact a superadmin for troubleshooting");
+            }
+        }
+        catch
+        {
+            ToastService.ShowError($"Error while disabling {node.Name}, please contact a superadmin for troubleshooting");
+        }
+    }
 
     private async Task GetData()
     {
@@ -235,9 +284,20 @@
         }
         else
         {
-            arg.Item.UpdateDatetime = DateTimeOffset.Now;
-            arg.Item.CreationDatetime = DateTimeOffset.Now;
-            var addResult = await NodeRepository.AddAsync(arg.Item);
+            Node newNode = arg.Item as Node;
+            (bool, string?) addResult;
+            var restoredNode = await NodeRepository.GetByPubkey(arg.Item.PubKey);
+         
+            if (restoredNode != null)
+            {
+                newNode.Id = restoredNode.Id;
+                newNode.CreationDatetime = restoredNode.CreationDatetime;
+                addResult =  NodeRepository.Update(newNode);
+            }
+            else
+            {
+                addResult = await NodeRepository.AddAsync(arg.Item);
+            }
             if (addResult.Item1)
             {
                 ToastService.ShowSuccess($"Node {arg.Item.Name} Created");
@@ -308,7 +368,10 @@
         {
             if (node != null)
             {
-                var (result, _) = NodeRepository.Remove(node);
+                node.IsNodeDisabled = true;
+                node.Endpoint = null;
+                node.ChannelAdminMacaroon = null;
+                var (result, _) = NodeRepository.Update(node);
                 if (!result)
                 {
                     ToastService.ShowError($"{node.Name} could not be deleted");
@@ -319,7 +382,7 @@
                     _nodes = await NodeRepository.GetAll();
 
                 }
-
+                await StopJob(node);
             }
         }
 
@@ -327,33 +390,73 @@
 
     }
 
+
+    private async Task StopJob(Node node)
+    {
+        try
+        {
+            IScheduler scheduler = await SchedulerFactory.GetScheduler();
+            
+            await SimpleJob.DeleteJob<NodeChannelSuscribeJob>(scheduler, node.Id.ToString());
+            await SimpleJob.DeleteJob<ProcessNodeChannelAcceptorJob>(scheduler, node.Id.ToString());
+            
+            node.JobId = null;
+        }
+        catch
+        {
+            ToastService.ShowError("Error while stopping jobs, please contact a superadmin for troubleshooting");
+        }
+    }
+
     private async Task CreateJobs(Node node)
     {
         try
         {
             IScheduler scheduler = await SchedulerFactory.GetScheduler();
+           
+            await UpsertJob<ProcessNodeChannelAcceptorJob>(scheduler, node, map =>
+            {
+                map.Put("managedNodeId", node.Id.ToString());
+            });
+            
+            await UpsertJob<NodeChannelSuscribeJob>(scheduler, node, map =>
+            {
+                map.Put("nodeId", node.Id);
+            });
+            
+            ToastService.ShowSuccess("Node subscription job created");
+        }
+        
+        catch
+        {
+            ToastService.ShowError("Error while requesting to open the channel, please contact a superadmin for troubleshooting");
+        }
+    }
 
+    private async Task UpsertJob<TJob>(IScheduler scheduler, Node node, Action<JobDataMap> configureMap) where TJob : IJob
+    {
+        var isJobExists = await SimpleJob.IsJobExists<TJob>(scheduler, node.Id.ToString());
+
+        if (isJobExists)
+        {
+            await SimpleJob.Reschedule<TJob>(scheduler, node.Id.ToString());
+        }
+        else
+        {
             var map = new JobDataMap();
-            map.Put("nodeId", node.Id);
+            configureMap(map);
+
+            var job = SimpleJob.Create<TJob>(map, node.Id.ToString());
 
-            var job = SimpleJob.Create<NodeChannelSuscribeJob>(map, node.Id.ToString());
             await scheduler.ScheduleJob(job.Job, job.Trigger);
 
             node.JobId = job.Job.Key.ToString();
 
-            var jobUpdateResult = NodeRepository.Update(node);
-
-            map = new JobDataMap();
-            map.Put("managedNodeId", node.Id.ToString());
-
-            var acceptorJob = SimpleJob.Create<ProcessNodeChannelAcceptorJob>(map, node.Id.ToString());
-            await scheduler.ScheduleJob(acceptorJob.Job, acceptorJob.Trigger);
-
-            ToastService.ShowSuccess("Node subscription job created");
-        }
-        catch
-        {
-            ToastService.ShowError("Error while requesting to open the channel, please contact a superadmin for troubleshooting");
+            var (result, _) = NodeRepository.Update(node);
+            if (!result)
+            {
+                ToastService.ShowError($"Error while subscribing to job for node {node.Name}");
+            }
         }
     }