diff --git a/TransactionProcessor.Aggregates/MerchantAggregate.cs b/TransactionProcessor.Aggregates/MerchantAggregate.cs
index 8369a08e..c7000e82 100644
--- a/TransactionProcessor.Aggregates/MerchantAggregate.cs
+++ b/TransactionProcessor.Aggregates/MerchantAggregate.cs
@@ -3,6 +3,7 @@
 using Shared.General;
 using SimpleResults;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using TransactionProcessor.DomainEvents;
 using TransactionProcessor.Models.Contract;
 using TransactionProcessor.Models.Merchant;
@@ -294,10 +295,13 @@ public static Result SwapDevice(this MerchantAggregate aggregate,
             if (result.IsFailed)
                 return result;
 
+            KeyValuePair<Guid, Device> originalDevice = aggregate.Devices.Single(d => d.Value.DeviceIdentifier == originalDeviceIdentifier);
+
             Guid deviceId = Guid.NewGuid();
             
-            MerchantDomainEvents.DeviceSwappedForMerchantEvent deviceSwappedForMerchantEvent = new MerchantDomainEvents.DeviceSwappedForMerchantEvent(aggregate.AggregateId, aggregate.EstateId,
-                                                                                                            deviceId, originalDeviceIdentifier, newDeviceIdentifier);
+            MerchantDomainEvents.DeviceSwappedForMerchantEvent deviceSwappedForMerchantEvent = new(aggregate.AggregateId, aggregate.EstateId,
+                                                                                                  deviceId, 
+                                                                                                  originalDevice.Value.DeviceId, newDeviceIdentifier);
 
             aggregate.ApplyAndAppend(deviceSwappedForMerchantEvent);
 
@@ -852,7 +856,7 @@ public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEve
 
         public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEvents.DeviceSwappedForMerchantEvent domainEvent)
         {
-            KeyValuePair<Guid, Device> device = aggregate.Devices.Single(d => d.Value.DeviceIdentifier == domainEvent.OriginalDeviceIdentifier);
+            KeyValuePair<Guid, Device> device = aggregate.Devices.Single(d => d.Key == domainEvent.OriginalDeviceId);
             aggregate.Devices[device.Key] = device.Value with{
                                                                  IsEnabled = false
                                                              };
diff --git a/TransactionProcessor.Database/Contexts/EstateManagementGenericContext.cs b/TransactionProcessor.Database/Contexts/EstateManagementGenericContext.cs
index ed43dea3..d68aec07 100644
--- a/TransactionProcessor.Database/Contexts/EstateManagementGenericContext.cs
+++ b/TransactionProcessor.Database/Contexts/EstateManagementGenericContext.cs
@@ -429,12 +429,26 @@ public static async Task<Result<Operator>> LoadOperator(this EstateManagementCon
         return loadOperatorResult;
     }
 
+    public static async Task<Result<MerchantDevice>> LoadOriginalMerchantDevice(this EstateManagementContext context, IDomainEvent domainEvent, CancellationToken cancellationToken)
+    {
+        Guid merchantId = DomainEventHelper.GetMerchantId(domainEvent);
+        Guid deviceId = DomainEventHelper.GetOriginalDeviceId(domainEvent);
+        MerchantDevice device = await context.MerchantDevices.SingleOrDefaultAsync(d => d.DeviceId == deviceId &&
+            d.MerchantId == merchantId, cancellationToken);
+
+        return device switch
+        {
+            null => Result.NotFound($"Original Device Id {deviceId} not found for Merchant {merchantId}"),
+            _ => Result.Success(device)
+        };
+    }
+
     public static async Task<Result<MerchantDevice>> LoadMerchantDevice(this EstateManagementContext context, IDomainEvent domainEvent, CancellationToken cancellationToken)
     {
         Guid merchantId = DomainEventHelper.GetMerchantId(domainEvent);
         Guid deviceId = DomainEventHelper.GetDeviceId(domainEvent);
         MerchantDevice device = await context.MerchantDevices.SingleOrDefaultAsync(d => d.DeviceId == deviceId &&
-            d.MerchantId == merchantId, cancellationToken);
+                                                                                        d.MerchantId == merchantId, cancellationToken);
 
         return device switch
         {
@@ -596,6 +610,7 @@ public static class DomainEventHelper
     public static Guid GetFileId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "FileId");
 
     public static Guid GetFileImportLogId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "FileImportLogId");
+    public static Guid GetOriginalDeviceId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "OriginalDeviceId");
     public static Guid GetDeviceId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "DeviceId");
     public static Guid GetMerchantId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "MerchantId");
     public static Guid GetAddressId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "AddressId");
diff --git a/TransactionProcessor.Database/Entities/MerchantDevice.cs b/TransactionProcessor.Database/Entities/MerchantDevice.cs
index c8f46bca..05514ccd 100644
--- a/TransactionProcessor.Database/Entities/MerchantDevice.cs
+++ b/TransactionProcessor.Database/Entities/MerchantDevice.cs
@@ -17,6 +17,7 @@ public class MerchantDevice
         public String DeviceIdentifier { get; set; }
         
         public Guid MerchantId { get; set; }
+        public Boolean IsEnabled { get; set; }
 
         #endregion
     }
diff --git a/TransactionProcessor.Database/Migrations/SqlServer/20260201193603_add_isenabled_to_merchantdevice.Designer.cs b/TransactionProcessor.Database/Migrations/SqlServer/20260201193603_add_isenabled_to_merchantdevice.Designer.cs
new file mode 100644
index 00000000..5e86f15e
--- /dev/null
+++ b/TransactionProcessor.Database/Migrations/SqlServer/20260201193603_add_isenabled_to_merchantdevice.Designer.cs
@@ -0,0 +1,1546 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using TransactionProcessor.Database.Contexts;
+
+#nullable disable
+
+namespace TransactionProcessor.Database.Migrations.SqlServer
+{
+    [DbContext(typeof(EstateManagementContext))]
+    [Migration("20260201193603_add_isenabled_to_merchantdevice")]
+    partial class add_isenabled_to_merchantdevice
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Calendar", b =>
+                {
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DayOfWeek")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("DayOfWeekNumber")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DayOfWeekShort")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("MonthNameLong")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("MonthNameShort")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("MonthNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WeekNumber")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WeekNumberString")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.Property<string>("YearWeekNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Date");
+
+                    b.ToTable("calendar");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Contract", b =>
+                {
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("OperatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("ContractReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("ContractReportingId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("EstateId", "OperatorId", "ContractId");
+
+                    b.ToTable("contract");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.ContractProduct", b =>
+                {
+                    b.Property<int>("ContractProductReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("ContractProductReportingId"));
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractProductId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("DisplayText")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ProductName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProductType")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("Value")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("ContractProductReportingId");
+
+                    b.HasIndex("ContractProductId", "ContractId")
+                        .IsUnique();
+
+                    b.ToTable("contractproduct");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.ContractProductTransactionFee", b =>
+                {
+                    b.Property<int>("ContractProductTransactionFeeReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("ContractProductTransactionFeeReportingId"));
+
+                    b.Property<int>("CalculationType")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("ContractProductId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractProductTransactionFeeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("FeeType")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<decimal>("Value")
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("ContractProductTransactionFeeReportingId");
+
+                    b.HasIndex("ContractProductTransactionFeeId", "ContractProductId")
+                        .IsUnique();
+
+                    b.ToTable("contractproducttransactionfee");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Estate", b =>
+                {
+                    b.Property<int>("EstateReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("EstateReportingId"));
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Reference")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("EstateReportingId");
+
+                    b.HasIndex("EstateId")
+                        .IsUnique();
+
+                    b.ToTable("estate");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.EstateOperator", b =>
+                {
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("OperatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.HasKey("EstateId", "OperatorId");
+
+                    b.ToTable("estateoperator");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.EstateSecurityUser", b =>
+                {
+                    b.Property<Guid>("SecurityUserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("SecurityUserId", "EstateId");
+
+                    b.ToTable("estatesecurityuser");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.File", b =>
+                {
+                    b.Property<int>("FileReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("FileReportingId"));
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("FileId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("FileImportLogId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("FileLocation")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("FileProfileId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("FileReceivedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("FileReceivedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("FileReportingId");
+
+                    b.HasIndex("FileId")
+                        .IsUnique();
+
+                    b.ToTable("file");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.FileImportLog", b =>
+                {
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("FileImportLogReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("FileImportLogReportingId"));
+
+                    b.Property<Guid>("FileImportLogId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("ImportLogDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("ImportLogDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("EstateId", "FileImportLogReportingId");
+
+                    b.HasIndex("EstateId", "FileImportLogId")
+                        .IsUnique();
+
+                    b.ToTable("fileimportlog");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.FileImportLogFile", b =>
+                {
+                    b.Property<Guid>("FileImportLogId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("FileId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("FilePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("FileProfileId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("FileUploadedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("FileUploadedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("FileImportLogId", "FileId");
+
+                    b.ToTable("fileimportlogfile");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.FileLine", b =>
+                {
+                    b.Property<Guid>("FileId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("LineNumber")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FileLineData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("FileId", "LineNumber");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("FileId", "LineNumber"));
+
+                    b.ToTable("fileline");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Float", b =>
+                {
+                    b.Property<Guid>("FloatId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ProductId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("FloatId");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("FloatId"), false);
+
+                    b.HasIndex("CreatedDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("CreatedDate"));
+
+                    b.ToTable("Floats");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.FloatActivity", b =>
+                {
+                    b.Property<Guid>("EventId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("ActivityDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("ActivityDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("CostPrice")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("CreditOrDebit")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("FloatId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("EventId");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("EventId"), false);
+
+                    b.HasIndex("ActivityDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("ActivityDate"));
+
+                    b.ToTable("FloatActivity");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Merchant", b =>
+                {
+                    b.Property<int>("MerchantReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("MerchantReportingId"));
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LastSaleDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("LastSaleDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("LastStatementGenerated")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Reference")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SettlementSchedule")
+                        .HasColumnType("int");
+
+                    b.HasKey("MerchantReportingId");
+
+                    b.HasIndex("EstateId", "MerchantId")
+                        .IsUnique();
+
+                    b.ToTable("merchant");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.MerchantAddress", b =>
+                {
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AddressId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AddressLine1")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AddressLine2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AddressLine3")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AddressLine4")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Region")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Town")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("MerchantId", "AddressId");
+
+                    b.ToTable("merchantaddress");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.MerchantContact", b =>
+                {
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContactId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("EmailAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("MerchantId", "ContactId");
+
+                    b.ToTable("merchantcontact");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.MerchantContract", b =>
+                {
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.HasKey("MerchantId", "ContractId");
+
+                    b.ToTable("MerchantContracts");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.MerchantDevice", b =>
+                {
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DeviceId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeviceIdentifier")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("bit");
+
+                    b.HasKey("MerchantId", "DeviceId");
+
+                    b.ToTable("merchantdevice");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.MerchantOperator", b =>
+                {
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("OperatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("MerchantNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TerminalNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("MerchantId", "OperatorId");
+
+                    b.ToTable("merchantoperator");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.MerchantSecurityUser", b =>
+                {
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("SecurityUserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("MerchantId", "SecurityUserId");
+
+                    b.ToTable("merchantsecurityuser");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.MerchantSettlementFee", b =>
+                {
+                    b.Property<Guid>("SettlementId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractProductTransactionFeeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<decimal>("CalculatedValue")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("FeeCalculatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<decimal>("FeeValue")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<bool>("IsSettled")
+                        .HasColumnType("bit");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("SettlementId", "TransactionId", "ContractProductTransactionFeeId");
+
+                    b.ToTable("merchantsettlementfee");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Operator", b =>
+                {
+                    b.Property<int>("OperatorReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("OperatorReportingId"));
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("OperatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("RequireCustomMerchantNumber")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("RequireCustomTerminalNumber")
+                        .HasColumnType("bit");
+
+                    b.HasKey("OperatorReportingId");
+
+                    b.HasIndex("OperatorId")
+                        .IsUnique();
+
+                    b.ToTable("operator");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Reconciliation", b =>
+                {
+                    b.Property<int>("TransactionReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("TransactionReportingId"));
+
+                    b.Property<string>("DeviceIdentifier")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsAuthorised")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ResponseCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ResponseMessage")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TransactionCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("TransactionDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("TransactionDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<TimeSpan>("TransactionTime")
+                        .HasColumnType("time");
+
+                    b.Property<decimal>("TransactionValue")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("TransactionReportingId");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("TransactionReportingId"), false);
+
+                    b.HasIndex("TransactionDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("TransactionDate"));
+
+                    b.HasIndex("TransactionId", "MerchantId")
+                        .IsUnique();
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("TransactionId", "MerchantId"), false);
+
+                    b.ToTable("reconciliation");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.ResponseCodes", b =>
+                {
+                    b.Property<int>("ResponseCode")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("ResponseCode"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("ResponseCode");
+
+                    b.ToTable("responsecodes");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Settlement", b =>
+                {
+                    b.Property<int>("SettlementReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("SettlementReportingId"));
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("ProcessingStarted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("ProcessingStartedDateTIme")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("SettlementDate")
+                        .HasColumnType("date");
+
+                    b.Property<Guid>("SettlementId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("SettlementReportingId");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("SettlementReportingId"), false);
+
+                    b.HasIndex("SettlementDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("SettlementDate"));
+
+                    b.HasIndex("EstateId", "SettlementId")
+                        .IsUnique();
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("EstateId", "SettlementId"), false);
+
+                    b.ToTable("settlement");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.StatementHeader", b =>
+                {
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("StatementId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("StatementCreatedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("StatementCreatedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("StatementGeneratedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("StatementGeneratedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("StatementReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("StatementReportingId"));
+
+                    b.HasKey("MerchantId", "StatementId");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("MerchantId", "StatementId"), false);
+
+                    b.HasIndex("StatementGeneratedDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("StatementGeneratedDate"));
+
+                    b.ToTable("statementheader");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.StatementLine", b =>
+                {
+                    b.Property<Guid>("StatementId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("ActivityDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("ActivityType")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("ActivityDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("ActivityDescription")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal>("InAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("OutAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("StatementId", "TransactionId", "ActivityDateTime", "ActivityType");
+
+                    b.ToTable("statementline");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Summary.SettlementSummary", b =>
+                {
+                    b.Property<int>("ContractProductReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("FeeCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("FeeValue")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsSettled")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("MerchantReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OperatorReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SalesCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("SalesValue")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("SettlementDate")
+                        .HasColumnType("date");
+
+                    b.HasIndex("SettlementDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("SettlementDate"));
+
+                    b.HasIndex("SettlementDate", "MerchantReportingId", "OperatorReportingId", "ContractProductReportingId", "IsCompleted", "IsSettled")
+                        .IsUnique();
+
+                    b.ToTable("SettlementSummary");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Summary.TodayTransaction", b =>
+                {
+                    b.Property<string>("AuthorisationCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ContractProductReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ContractReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DeviceIdentifier")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Hour")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsAuthorised")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("MerchantReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OperatorReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ResponseCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ResponseMessage")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal>("TransactionAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("TransactionDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("TransactionDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("TransactionNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TransactionReference")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TransactionReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransactionSource")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("TransactionTime")
+                        .HasColumnType("time");
+
+                    b.Property<string>("TransactionType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasIndex("TransactionDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("TransactionDate"));
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    b.ToTable("TodayTransactions");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Summary.TransactionHistory", b =>
+                {
+                    b.Property<string>("AuthorisationCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ContractProductReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ContractReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DeviceIdentifier")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Hour")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsAuthorised")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("MerchantReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OperatorReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ResponseCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ResponseMessage")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal>("TransactionAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("TransactionDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("TransactionDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("TransactionNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TransactionReference")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TransactionReportingId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TransactionSource")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("TransactionTime")
+                        .HasColumnType("time");
+
+                    b.Property<string>("TransactionType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasIndex("TransactionDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("TransactionDate"));
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    b.ToTable("TransactionHistory");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.Transaction", b =>
+                {
+                    b.Property<int>("TransactionReportingId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("TransactionReportingId"));
+
+                    b.Property<string>("AuthorisationCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractProductId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("DeviceIdentifier")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsAuthorised")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("OperatorId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ResponseCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ResponseMessage")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal>("TransactionAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("TransactionDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("TransactionDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("TransactionNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TransactionReference")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TransactionSource")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("TransactionTime")
+                        .HasColumnType("time");
+
+                    b.Property<string>("TransactionType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("TransactionReportingId");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("TransactionReportingId"), false);
+
+                    b.HasIndex("TransactionDate");
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("TransactionDate"));
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    SqlServerIndexBuilderExtensions.IsClustered(b.HasIndex("TransactionId"), false);
+
+                    b.ToTable("transaction");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.TransactionAdditionalRequestData", b =>
+                {
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Amount")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CustomerAccountNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("TransactionId");
+
+                    b.ToTable("transactionadditionalrequestdata");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.TransactionAdditionalResponseData", b =>
+                {
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("TransactionReportingId")
+                        .HasColumnType("int");
+
+                    b.HasKey("TransactionId");
+
+                    b.ToTable("transactionadditionalresponsedata");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.TransactionTimings", b =>
+                {
+                    b.Property<Guid>("TransactionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("OperatorCommunicationsCompletedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<double>("OperatorCommunicationsDurationInMilliseconds")
+                        .HasColumnType("float");
+
+                    b.Property<DateTime?>("OperatorCommunicationsStartedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<double>("TotalTransactionInMilliseconds")
+                        .HasColumnType("float");
+
+                    b.Property<DateTime>("TransactionCompletedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<double>("TransactionProcessingDurationInMilliseconds")
+                        .HasColumnType("float");
+
+                    b.Property<DateTime>("TransactionStartedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("TransactionId");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("TransactionId"), false);
+
+                    b.ToTable("transactiontimings");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.Entities.VoucherProjectionState", b =>
+                {
+                    b.Property<Guid>("VoucherId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Barcode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("ExpiryDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("ExpiryDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("GenerateDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("GenerateDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsGenerated")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsIssued")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsRedeemed")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("IssuedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("IssuedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("OperatorIdentifier")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RecipientEmail")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RecipientMobile")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("RedeemedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("RedeemedDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<byte[]>("Timestamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<decimal>("Value")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("VoucherCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("VoucherId");
+
+                    b.HasIndex("TransactionId");
+
+                    b.HasIndex("VoucherCode");
+
+                    b.ToTable("voucherprojectionstate");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.Database.ViewEntities.SettlementView", b =>
+                {
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("CalculatedValue")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("DayOfWeek")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("FeeDescription")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsSettled")
+                        .HasColumnType("bit");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("MerchantName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Month")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("MonthNumber")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OperatorIdentifier")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("SettlementDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("SettlementId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("WeekNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int>("YearNumber")
+                        .HasColumnType("int");
+
+                    b.ToTable((string)null);
+
+                    b.ToView("uvwSettlements", (string)null);
+                });
+
+            modelBuilder.Entity("TransactionProcessor.ProjectionEngine.Database.Database.Entities.Event", b =>
+                {
+                    b.Property<Guid>("EventId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("date");
+
+                    b.HasKey("EventId", "Type");
+
+                    SqlServerKeyBuilderExtensions.IsClustered(b.HasKey("EventId", "Type"));
+
+                    b.ToTable("Events");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.ProjectionEngine.Database.Database.Entities.MerchantBalanceChangedEntry", b =>
+                {
+                    b.Property<Guid>("AggregateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("OriginalEventId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CauseOfChangeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<decimal>("ChangeAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("DateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DebitOrCredit")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Reference")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("AggregateId", "OriginalEventId");
+
+                    b.ToTable("MerchantBalanceChangedEntry");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.ProjectionEngine.Database.Database.Entities.MerchantBalanceProjectionState", b =>
+                {
+                    b.Property<Guid>("EstateId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<decimal>("AuthorisedSales")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("AvailableBalance")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Balance")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("CompletedTransactionCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("DeclinedSales")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("DepositCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FeeCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("LastDeposit")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("LastFee")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("LastSale")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("LastWithdrawal")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("MerchantName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SaleCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StartedTransactionCount")
+                        .HasColumnType("int");
+
+                    b.Property<byte[]>("Timestamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<decimal>("TotalDeposited")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TotalWithdrawn")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("ValueOfFees")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("WithdrawalCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("EstateId", "MerchantId");
+
+                    b.ToTable("MerchantBalanceProjectionState");
+                });
+
+            modelBuilder.Entity("TransactionProcessor.ProjectionEngine.Database.Database.ViewEntities.MerchantBalanceHistoryViewEntry", b =>
+                {
+                    b.Property<decimal>("Balance")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("ChangeAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("DebitOrCredit")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("EntryDateTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("MerchantId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("OriginalEventId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Reference")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.ToTable((string)null);
+
+                    b.ToView("uvwMerchantBalanceHistory", (string)null);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/TransactionProcessor.Database/Migrations/SqlServer/20260201193603_add_isenabled_to_merchantdevice.cs b/TransactionProcessor.Database/Migrations/SqlServer/20260201193603_add_isenabled_to_merchantdevice.cs
new file mode 100644
index 00000000..d1f76b57
--- /dev/null
+++ b/TransactionProcessor.Database/Migrations/SqlServer/20260201193603_add_isenabled_to_merchantdevice.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace TransactionProcessor.Database.Migrations.SqlServer
+{
+    /// <inheritdoc />
+    public partial class add_isenabled_to_merchantdevice : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsEnabled",
+                table: "merchantdevice",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsEnabled",
+                table: "merchantdevice");
+        }
+    }
+}
diff --git a/TransactionProcessor.Database/Migrations/SqlServer/EstateManagementSqlServerContextModelSnapshot.cs b/TransactionProcessor.Database/Migrations/SqlServer/EstateManagementSqlServerContextModelSnapshot.cs
index 9ec47464..55a4759d 100644
--- a/TransactionProcessor.Database/Migrations/SqlServer/EstateManagementSqlServerContextModelSnapshot.cs
+++ b/TransactionProcessor.Database/Migrations/SqlServer/EstateManagementSqlServerContextModelSnapshot.cs
@@ -580,6 +580,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("bit");
+
                     b.HasKey("MerchantId", "DeviceId");
 
                     b.ToTable("merchantdevice");
diff --git a/TransactionProcessor.DatabaseTests/BaseTest.cs b/TransactionProcessor.DatabaseTests/BaseTest.cs
index 56b9cb45..7c6135e9 100644
--- a/TransactionProcessor.DatabaseTests/BaseTest.cs
+++ b/TransactionProcessor.DatabaseTests/BaseTest.cs
@@ -1,28 +1,18 @@
-using Ductus.FluentDocker.Services;
-using Ductus.FluentDocker.Services.Extensions;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.Extensions.Configuration;
+using System.Diagnostics;
+using DotNet.Testcontainers.Builders;
+using DotNet.Testcontainers.Networks;
 using Microsoft.Extensions.DependencyInjection;
 using Moq;
 using NLog;
 using Shared.EntityFramework;
 using Shared.IntegrationTesting;
+using Shared.IntegrationTesting.TestContainers;
 using Shared.Logger;
 using Shouldly;
-using SimpleResults;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net.Http.Headers;
-using System.Text;
-using System.Threading.Tasks;
-using Shared.IntegrationTesting.Ductus;
 using TransactionProcessor.Database.Contexts;
 using TransactionProcessor.Repository;
 using Xunit.Abstractions;
 using Logger = Shared.Logger.Logger;
-using NullLogger = Microsoft.Extensions.Logging.Abstractions.NullLogger;
 
 namespace TransactionProcessor.DatabaseTests
 {
@@ -76,43 +66,43 @@ public virtual async Task DisposeAsync()
         
         protected Guid TestId;
         
-        public static IContainerService DatabaseServerContainer;
-        public static INetworkService DatabaseServerNetwork;
+        public static INetwork DatabaseServerNetwork;
         public static (String usename, String password) SqlCredentials = ("sa", "thisisalongpassword123!");
 
-        public static String GetLocalConnectionString(String databaseName)
+        public String GetLocalConnectionString(String databaseName)
         {
-            Int32 databaseHostPort = DatabaseServerContainer.ToHostExposedEndpoint("1433/tcp").Port;
-
+            Int32? databaseHostPort = DockerHelper.GetHostPort(ContainerType.SqlServer);
+            
             return $"server=localhost,{databaseHostPort};database={databaseName};user id={SqlCredentials.usename};password={SqlCredentials.password};Encrypt=false";
         }
 
+        private DockerHelper DockerHelper;
+
         internal async Task StartSqlContainer()
         {
-            DockerHelper dockerHelper = new TestDockerHelper();
+            DockerHelper = new TestDockerHelper();
 
             NlogLogger logger = new NlogLogger();
             logger.Initialise(LogManager.GetLogger("Specflow"), "Specflow");
             LogManager.AddHiddenAssembly(typeof(NlogLogger).Assembly);
-            dockerHelper.Logger = logger;
-            dockerHelper.SqlCredentials = SqlCredentials;
-            dockerHelper.SqlServerContainerName = "sharedsqlserver_repotests";
-            dockerHelper.RequiredDockerServices = DockerServices.SqlServer;
-
-            DatabaseServerNetwork = dockerHelper.SetupTestNetwork("sharednetwork", true);
-            await Retry.For(async () => {
-                DatabaseServerContainer = await dockerHelper.SetupSqlServerContainer(DatabaseServerNetwork);
-            });
+            DockerHelper.Logger = logger;
+            DockerHelper.SqlCredentials = SqlCredentials;
+            DockerHelper.SqlServerContainerName = $"sqlserver_{this.TestId}";
+            DockerHelper.RequiredDockerServices = DockerServices.SqlServer;
+
+            //DatabaseServerNetwork = await DockerHelper.SetupTestNetwork($"nw{this.TestId}", true);
+            await DockerHelper.StartContainersForScenarioRun(this.TestId.ToString(), DockerServices.SqlServer);
         }
 
         public void Dispose()
         {
-            EstateManagementContext context = new EstateManagementContext(BaseTest.GetLocalConnectionString($"EstateReportingReadModel{this.TestId.ToString()}"));
+            EstateManagementContext context = new EstateManagementContext(this.GetLocalConnectionString($"EstateReportingReadModel{this.TestId.ToString()}"));
 
             Console.WriteLine($"About to delete database EstateReportingReadModel{this.TestId.ToString()}");
             Boolean result = context.Database.EnsureDeleted();
             Console.WriteLine($"Delete result is {result}");
             result.ShouldBeTrue();
+            
         }
     }
 
diff --git a/TransactionProcessor.DatabaseTests/ContractEventTests.cs b/TransactionProcessor.DatabaseTests/ContractEventTests.cs
index 3192684c..7cf896fa 100644
--- a/TransactionProcessor.DatabaseTests/ContractEventTests.cs
+++ b/TransactionProcessor.DatabaseTests/ContractEventTests.cs
@@ -13,6 +13,93 @@
 
 namespace TransactionProcessor.DatabaseTests
 {
+    public class MerchantEventTests : BaseTest {
+        [Fact]
+        public async Task AddMerchant_MerchantIsAdded() {
+            Result result = await this.Repository.AddMerchant(TestData.DomainEvents.MerchantCreatedEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+            EstateManagementContext context = this.GetContext();
+            Merchant? merchant = await context.Merchants.SingleOrDefaultAsync(c => c.MerchantId == TestData.DomainEvents.MerchantCreatedEvent.MerchantId);
+            merchant.ShouldNotBeNull();
+        }
+
+        [Fact]
+        public async Task AddMerchant_EventReplayHandled() {
+            Result result = await this.Repository.AddMerchant(TestData.DomainEvents.MerchantCreatedEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+            result = await this.Repository.AddMerchant(TestData.DomainEvents.MerchantCreatedEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+        }
+
+        [Fact]
+        public async Task AddMerchantDevice_MerchantContractIsAdded() {
+            Result result = await this.Repository.AddMerchantDevice(TestData.DomainEvents.DeviceAddedToMerchantEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+            EstateManagementContext context = this.GetContext();
+            var merchantDevice = await context.MerchantDevices.SingleOrDefaultAsync(c => c.DeviceId == TestData.DomainEvents.DeviceAddedToMerchantEvent.DeviceId);
+            merchantDevice.ShouldNotBeNull();
+        }
+
+        [Fact]
+        public async Task AddMerchantDevice_EventReplayHandled() {
+            Result result = await this.Repository.AddMerchantDevice(TestData.DomainEvents.DeviceAddedToMerchantEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+            result = await this.Repository.AddMerchantDevice(TestData.DomainEvents.DeviceAddedToMerchantEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+        }
+
+        [Fact]
+        public async Task SwapMerchantDevice_MerchantContractIsAdded()
+        {
+            Result result = await this.Repository.AddMerchantDevice(TestData.DomainEvents.DeviceAddedToMerchantEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+            result = await this.Repository.SwapMerchantDevice(TestData.DomainEvents.DeviceSwappedForMerchantEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+            EstateManagementContext context = this.GetContext();
+            var merchantDevice = await context.MerchantDevices.SingleOrDefaultAsync(c => c.DeviceId == TestData.DomainEvents.DeviceAddedToMerchantEvent.DeviceId);
+            merchantDevice.ShouldNotBeNull();
+            merchantDevice.DeviceIdentifier.ShouldBe(TestData.DomainEvents.DeviceAddedToMerchantEvent.DeviceIdentifier);
+            merchantDevice.IsEnabled.ShouldBeFalse();
+
+            merchantDevice = await context.MerchantDevices.SingleOrDefaultAsync(c => c.DeviceId == TestData.DomainEvents.DeviceSwappedForMerchantEvent.DeviceId);
+            merchantDevice.ShouldNotBeNull();
+            merchantDevice.DeviceIdentifier.ShouldBe(TestData.DomainEvents.DeviceSwappedForMerchantEvent.NewDeviceIdentifier);
+            merchantDevice.IsEnabled.ShouldBeTrue();
+        }
+
+        [Fact]
+        public async Task SwapMerchantDevice_EventReplayHandled()
+        {
+            Result result = await this.Repository.AddMerchantDevice(TestData.DomainEvents.DeviceAddedToMerchantEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+            result = await this.Repository.SwapMerchantDevice(TestData.DomainEvents.DeviceSwappedForMerchantEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+            EstateManagementContext context = this.GetContext();
+            var merchantDevice = await context.MerchantDevices.SingleOrDefaultAsync(c => c.DeviceId == TestData.DomainEvents.DeviceAddedToMerchantEvent.DeviceId);
+            merchantDevice.ShouldNotBeNull();
+            merchantDevice.DeviceIdentifier.ShouldBe(TestData.DomainEvents.DeviceAddedToMerchantEvent.DeviceIdentifier);
+            merchantDevice.IsEnabled.ShouldBeFalse();
+
+            merchantDevice = await context.MerchantDevices.SingleOrDefaultAsync(c => c.DeviceId == TestData.DomainEvents.DeviceSwappedForMerchantEvent.DeviceId);
+            merchantDevice.ShouldNotBeNull();
+            merchantDevice.DeviceIdentifier.ShouldBe(TestData.DomainEvents.DeviceSwappedForMerchantEvent.NewDeviceIdentifier);
+            merchantDevice.IsEnabled.ShouldBeTrue();
+
+            result = await this.Repository.SwapMerchantDevice(TestData.DomainEvents.DeviceSwappedForMerchantEvent, CancellationToken.None);
+            result.IsSuccess.ShouldBeTrue();
+
+            merchantDevice = await context.MerchantDevices.SingleOrDefaultAsync(c => c.DeviceId == TestData.DomainEvents.DeviceAddedToMerchantEvent.DeviceId);
+            merchantDevice.ShouldNotBeNull();
+            merchantDevice.DeviceIdentifier.ShouldBe(TestData.DomainEvents.DeviceAddedToMerchantEvent.DeviceIdentifier);
+            merchantDevice.IsEnabled.ShouldBeFalse();
+
+            merchantDevice = await context.MerchantDevices.SingleOrDefaultAsync(c => c.DeviceId == TestData.DomainEvents.DeviceSwappedForMerchantEvent.DeviceId);
+            merchantDevice.ShouldNotBeNull();
+            merchantDevice.DeviceIdentifier.ShouldBe(TestData.DomainEvents.DeviceSwappedForMerchantEvent.NewDeviceIdentifier);
+            merchantDevice.IsEnabled.ShouldBeTrue();
+        }
+    }
+
 
     public class ContractEventTests : BaseTest
     {
diff --git a/TransactionProcessor.DatabaseTests/TransactionProcessor.DatabaseTests.csproj b/TransactionProcessor.DatabaseTests/TransactionProcessor.DatabaseTests.csproj
index 53bcd56f..5d50a9d6 100644
--- a/TransactionProcessor.DatabaseTests/TransactionProcessor.DatabaseTests.csproj
+++ b/TransactionProcessor.DatabaseTests/TransactionProcessor.DatabaseTests.csproj
@@ -5,7 +5,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
-	  <DebugType>None</DebugType>
+	  <DebugType>Full</DebugType>
   </PropertyGroup>
 
   <ItemGroup>
@@ -22,7 +22,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-	  <PackageReference Include="Shared.IntegrationTesting" Version="2025.12.2" />
+	  <PackageReference Include="Shared.IntegrationTesting" Version="2026.2.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/TransactionProcessor.DomainEvents/MerchantDomainEvents.cs b/TransactionProcessor.DomainEvents/MerchantDomainEvents.cs
index 95943591..812619da 100644
--- a/TransactionProcessor.DomainEvents/MerchantDomainEvents.cs
+++ b/TransactionProcessor.DomainEvents/MerchantDomainEvents.cs
@@ -9,7 +9,7 @@ public record AddressAddedEvent(Guid MerchantId, Guid EstateId, Guid AddressId,
         public record AutomaticDepositMadeEvent(Guid MerchantId, Guid EstateId, Guid DepositId, String Reference, DateTime DepositDateTime, Decimal Amount) : DomainEvent(MerchantId, Guid.NewGuid());
         public record ContactAddedEvent(Guid MerchantId, Guid EstateId, Guid ContactId, String ContactName, String ContactPhoneNumber, String ContactEmailAddress) : DomainEvent(MerchantId, Guid.NewGuid());
         public record DeviceAddedToMerchantEvent(Guid MerchantId, Guid EstateId, Guid DeviceId, String DeviceIdentifier) : DomainEvent(MerchantId, Guid.NewGuid());
-        public record DeviceSwappedForMerchantEvent(Guid MerchantId, Guid EstateId, Guid DeviceId, String OriginalDeviceIdentifier, String NewDeviceIdentifier) : DomainEvent(MerchantId, Guid.NewGuid());
+        public record DeviceSwappedForMerchantEvent(Guid MerchantId, Guid EstateId, Guid DeviceId, Guid OriginalDeviceId, String NewDeviceIdentifier) : DomainEvent(MerchantId, Guid.NewGuid());
         public record ManualDepositMadeEvent(Guid MerchantId, Guid EstateId, Guid DepositId, String Reference, DateTime DepositDateTime, Decimal Amount) : DomainEvent(MerchantId, Guid.NewGuid());
         public record MerchantCreatedEvent(Guid MerchantId, Guid EstateId, String MerchantName, DateTime DateCreated) : DomainEvent(MerchantId, Guid.NewGuid());
         public record MerchantDepositListCreatedEvent(Guid MerchantId, Guid EstateId, DateTime DateCreated) : DomainEvent(MerchantId, Guid.NewGuid());
diff --git a/TransactionProcessor.Repository/ITransactionProcessorReadModelRepository.cs b/TransactionProcessor.Repository/ITransactionProcessorReadModelRepository.cs
index ce160fc7..495caf05 100644
--- a/TransactionProcessor.Repository/ITransactionProcessorReadModelRepository.cs
+++ b/TransactionProcessor.Repository/ITransactionProcessorReadModelRepository.cs
@@ -359,7 +359,7 @@ public async Task<Result> AddMerchant(MerchantDomainEvents.MerchantCreatedEvent
 
             await context.Merchants.AddAsync(merchant, cancellationToken);
 
-            return await context.SaveChangesAsync(cancellationToken);
+            return await context.SaveChangesWithDuplicateHandling(cancellationToken);
         }
 
         public async Task<Result> UpdateMerchant(MerchantNameUpdatedEvent domainEvent, CancellationToken cancellationToken)
@@ -423,8 +423,7 @@ public async Task<Result> AddMerchantDevice(DeviceAddedToMerchantEvent domainEve
         {
             EstateManagementContext context = await this.GetContext(domainEvent.EstateId);
 
-            MerchantDevice merchantDevice = new MerchantDevice
-            {
+            MerchantDevice merchantDevice = new() {
                 MerchantId = domainEvent.MerchantId,
                 DeviceId = domainEvent.DeviceId,
                 DeviceIdentifier = domainEvent.DeviceIdentifier
@@ -432,21 +431,24 @@ public async Task<Result> AddMerchantDevice(DeviceAddedToMerchantEvent domainEve
 
             await context.MerchantDevices.AddAsync(merchantDevice, cancellationToken);
 
-            return await context.SaveChangesAsync(cancellationToken);
+            return await context.SaveChangesWithDuplicateHandling(cancellationToken);
         }
 
         public async Task<Result> SwapMerchantDevice(DeviceSwappedForMerchantEvent domainEvent, CancellationToken cancellationToken)
         {
             EstateManagementContext context = await this.GetContext(domainEvent.EstateId);
 
-            var getDeviceResult = await context.LoadMerchantDevice(domainEvent, cancellationToken);
-            if (getDeviceResult.IsFailed)
-                return ResultHelpers.CreateFailure(getDeviceResult);
-            var device = getDeviceResult.Data;
+            Result<MerchantDevice> getOriginalDeviceResult = await context.LoadOriginalMerchantDevice(domainEvent, cancellationToken);
+            if (getOriginalDeviceResult.IsFailed)
+                return ResultHelpers.CreateFailure(getOriginalDeviceResult);
+            MerchantDevice? originalDevice = getOriginalDeviceResult.Data;
 
-            device.DeviceIdentifier = domainEvent.NewDeviceIdentifier;
+            originalDevice.IsEnabled = false;
 
-            return await context.SaveChangesAsync(cancellationToken);
+            MerchantDevice newDevice = new() { DeviceId = domainEvent.DeviceId, IsEnabled = true, DeviceIdentifier = domainEvent.NewDeviceIdentifier, MerchantId = domainEvent.MerchantId };
+            await context.MerchantDevices.AddAsync(newDevice, cancellationToken);
+
+            return await context.SaveChangesWithDuplicateHandling(cancellationToken);
         }
 
         public async Task<Result> AddMerchantOperator(OperatorAssignedToMerchantEvent domainEvent,
diff --git a/TransactionProcessor.Testing/TestData.cs b/TransactionProcessor.Testing/TestData.cs
index a7fcfb42..eaaf52a6 100644
--- a/TransactionProcessor.Testing/TestData.cs
+++ b/TransactionProcessor.Testing/TestData.cs
@@ -353,7 +353,8 @@ public class TestData
         public static String DeclinedResponseMessage = "DeclinedResponseMessage";
 
         public static Guid DeviceId = Guid.Parse("840F32FF-8B74-467C-8078-F5D9297FED56");
-
+        public static Guid OriginalDeviceId = Guid.Parse("840F32FF-8B74-467C-8078-F5D9297FED56");
+        public static Guid NewDeviceId = Guid.Parse("55C261AC-7E80-47E1-9169-4041329D3F12");
         public static String DeviceIdentifier = "1234567890";
 
         public static String DeviceIdentifier1 = "1234567891";
@@ -2690,8 +2691,8 @@ public static class DomainEvents {
             public static MerchantDomainEvents.DeviceSwappedForMerchantEvent DeviceSwappedForMerchantEvent =>
                 new MerchantDomainEvents.DeviceSwappedForMerchantEvent(TestData.MerchantId,
                     TestData.EstateId,
-                    TestData.DeviceId,
-                    TestData.DeviceIdentifier,
+                    TestData.NewDeviceId,
+                    TestData.OriginalDeviceId,
                     TestData.NewDeviceIdentifier);
 
             public static MerchantDomainEvents.OperatorRemovedFromMerchantEvent OperatorRemovedFromMerchantEvent => new MerchantDomainEvents.OperatorRemovedFromMerchantEvent(TestData.MerchantId, TestData.EstateId, TestData.OperatorId);