diff --git a/TransactionProcessor.Aggregates.Tests/MerchantAggregateTests.cs b/TransactionProcessor.Aggregates.Tests/MerchantAggregateTests.cs
index f203951b..a5bfa0bb 100644
--- a/TransactionProcessor.Aggregates.Tests/MerchantAggregateTests.cs
+++ b/TransactionProcessor.Aggregates.Tests/MerchantAggregateTests.cs
@@ -818,5 +818,32 @@ public void MerchantAggregate_RemoveOperator_And_ReAdd_OperatorIsReAdded()
             operatorModel = merchantModel.Operators.Single();
             operatorModel.IsDeleted.ShouldBeFalse();
         }
+
+        [Fact]
+        public void MerchantAggregate_RemoveContract_And_ReAdd_ContractIsReAdded()
+        {
+            MerchantAggregate aggregate = MerchantAggregate.Create(TestData.MerchantId);
+            aggregate.Create(TestData.EstateId, TestData.MerchantName, TestData.DateMerchantCreated, TestData.AddressModel, TestData.ContactModel,
+                TestData.SettlementScheduleModel);
+            aggregate.AddContract(TestData.Aggregates.CreatedContractAggregate());
+
+            Result result = aggregate.RemoveContract(TestData.ContractId);
+            result.IsSuccess.ShouldBeTrue();
+
+            Merchant merchantModel = aggregate.GetMerchant();
+            merchantModel.Contracts.ShouldHaveSingleItem();
+            Contract contractModel = merchantModel.Contracts.Single();
+            contractModel.ContractId.ShouldBe(TestData.ContractId);
+            contractModel.IsDeleted.ShouldBeTrue();
+
+            result = aggregate.AddContract(TestData.Aggregates.CreatedContractAggregate());
+            result.IsSuccess.ShouldBeTrue();
+
+            merchantModel = aggregate.GetMerchant();
+            merchantModel.Contracts.ShouldHaveSingleItem();
+            contractModel = merchantModel.Contracts.Single();
+            contractModel.ContractId.ShouldBe(TestData.ContractId);
+            contractModel.IsDeleted.ShouldBeFalse();
+        }
     }
 }
diff --git a/TransactionProcessor.Aggregates/MerchantAggregate.cs b/TransactionProcessor.Aggregates/MerchantAggregate.cs
index a4c0b48b..8369a08e 100644
--- a/TransactionProcessor.Aggregates/MerchantAggregate.cs
+++ b/TransactionProcessor.Aggregates/MerchantAggregate.cs
@@ -621,7 +621,7 @@ private static Result EnsureOperatorHasBeenAssigned(this MerchantAggregate aggre
 
         private static Result EnsureContractHasNotAlreadyBeenAdded(this MerchantAggregate aggregate,
                                                                    Guid contractId) {
-            if (aggregate.Contracts.ContainsKey(contractId)) {
+            if (aggregate.Contracts.Any(o => o.Key == contractId && o.Value.IsDeleted == false)) {
                 return Result.Invalid($"Contract {contractId} has already been assigned to merchant");
             }
 
@@ -785,19 +785,21 @@ public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEve
             aggregate.Contacts.Add(contactAddedEvent.ContactId, contact);
         }
 
-        public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEvents.OperatorAssignedToMerchantEvent operatorAssignedToMerchantEvent) {
-            var @operator = aggregate.Operators.SingleOrDefault(o => o.Key == operatorAssignedToMerchantEvent.OperatorId);
-
-            if (@operator.Value != null) {
-                aggregate.Operators[operatorAssignedToMerchantEvent.OperatorId] = @operator.Value with { IsDeleted = false };
+        public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEvents.OperatorAssignedToMerchantEvent domainEvent) {
+            if (aggregate.Operators.ContainsKey(domainEvent.OperatorId))
+            {
+                KeyValuePair<Guid, Operator> @operator = aggregate.Operators.Single(c => c.Key == domainEvent.OperatorId);
+                aggregate.Operators[domainEvent.OperatorId] = @operator.Value with
+                {
+                    IsDeleted = false
+                };
                 return;
             }
+            Operator newOperator = new Operator(domainEvent.OperatorId, domainEvent.Name,
+                domainEvent.MerchantNumber,
+                domainEvent.TerminalNumber);
 
-            Operator newOperator = new Operator(operatorAssignedToMerchantEvent.OperatorId, operatorAssignedToMerchantEvent.Name,
-                                              operatorAssignedToMerchantEvent.MerchantNumber,
-                                              operatorAssignedToMerchantEvent.TerminalNumber);
-
-            aggregate.Operators.Add(operatorAssignedToMerchantEvent.OperatorId, newOperator);
+            aggregate.Operators.Add(domainEvent.OperatorId, newOperator);
         }
 
         public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEvents.OperatorRemovedFromMerchantEvent operatorRemovedFromMerchantEvent){
@@ -822,6 +824,14 @@ public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEve
         }
 
         public static void PlayEvent(this MerchantAggregate aggregate, MerchantDomainEvents.ContractAddedToMerchantEvent domainEvent){
+            if (aggregate.Contracts.ContainsKey(domainEvent.ContractId)) {
+                KeyValuePair<Guid, Contract> contract = aggregate.Contracts.Single(c => c.Key == domainEvent.ContractId);
+                aggregate.Contracts[domainEvent.ContractId] = contract.Value with
+                {
+                    IsDeleted = false
+                };
+                return;
+            }
             aggregate.Contracts.Add(domainEvent.ContractId, new Contract(domainEvent.ContractId));
         }