diff --git a/TransactionProcessor.BusinessLogic/Services/MerchantDomainService.cs b/TransactionProcessor.BusinessLogic/Services/MerchantDomainService.cs
index 935d4934..d882635f 100644
--- a/TransactionProcessor.BusinessLogic/Services/MerchantDomainService.cs
+++ b/TransactionProcessor.BusinessLogic/Services/MerchantDomainService.cs
@@ -79,20 +79,11 @@ public MerchantDomainService(Func<IAggregateService> aggregateService,
 
         public async Task<Result> AddDeviceToMerchant(MerchantCommands.AddMerchantDeviceCommand command, CancellationToken cancellationToken) {
             try {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Guid deviceId = Guid.NewGuid();
                 Result stateResult = merchantAggregate.AddDevice(deviceId, command.RequestDto.DeviceIdentifier);
@@ -111,23 +102,15 @@ public async Task<Result> AddDeviceToMerchant(MerchantCommands.AddMerchantDevice
         }
 
         public async Task<Result> AssignOperatorToMerchant(MerchantCommands.AssignOperatorToMerchantCommand command,
-                                                                 CancellationToken cancellationToken)
+                                                                  CancellationToken cancellationToken)
         {
             try {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
-
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                EstateAggregate estateAggregate = contextResult.Data.EstateAggregate;
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 (Result validationResult, String operatorName) = await this.GetOperatorAssignmentDetails(command, estateAggregate, cancellationToken);
                 if (validationResult.IsFailed)
@@ -265,20 +248,11 @@ public async Task<Result> CreateMerchantUser(MerchantCommands.CreateMerchantUser
             try {
                 CreateUserRequest createUserRequest = this.BuildMerchantUserRequest(command);
 
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result validateResult = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (validateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(validateResult);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result<UserDetails> getUserResult = await this.CreateMerchantSecurityUser(createUserRequest, cancellationToken);
                 if (getUserResult.IsFailed)
@@ -343,21 +317,11 @@ public async Task<Result> MakeMerchantDeposit(MerchantCommands.MakeMerchantDepos
         {
             try
             {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken, false);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result validateResult =
-                    this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (validateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(validateResult);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result<MerchantDepositListAggregate> depositListResult = await this.GetOrCreateMerchantDepositList(command, merchantAggregate, cancellationToken);
                 if (depositListResult.IsFailed)
@@ -418,20 +382,11 @@ public async Task<Result> MakeMerchantWithdrawal(MerchantCommands.MakeMerchantWi
         public async Task<Result> AddContractToMerchant(MerchantCommands.AddMerchantContractCommand command, CancellationToken cancellationToken)
         {
             try {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result validateResult = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (validateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(validateResult);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result<ContractAggregate> contractResult = await this.GetCreatedContract(command.RequestDto.ContractId, cancellationToken);
                 if (contractResult.IsFailed)
@@ -455,20 +410,11 @@ public async Task<Result> AddContractToMerchant(MerchantCommands.AddMerchantCont
         public async Task<Result> UpdateMerchant(MerchantCommands.UpdateMerchantCommand command, CancellationToken cancellationToken)
         {
             try {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
-
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result result = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result stateResult = merchantAggregate.UpdateMerchant(command.RequestDto.Name);
                 if (stateResult.IsFailed)
@@ -493,21 +439,11 @@ public async Task<Result> AddMerchantAddress(MerchantCommands.AddMerchantAddress
         {
             try
             {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
-
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result =
-                    this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Address address = Address.Create(Guid.Empty, command.RequestDto.AddressLine1, command.RequestDto.AddressLine2, command.RequestDto.AddressLine3, command.RequestDto.AddressLine4, command.RequestDto.Town, command.RequestDto.Region, command.RequestDto.PostalCode, command.RequestDto.Country);
 
@@ -531,21 +467,11 @@ public async Task<Result> UpdateMerchantAddress(MerchantCommands.UpdateMerchantA
         {
             try
             {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result =
-                    this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Address address = Address.Create(command.AddressId, command.RequestDto.AddressLine1, command.RequestDto.AddressLine2, command.RequestDto.AddressLine3, command.RequestDto.AddressLine4, command.RequestDto.Town, command.RequestDto.Region, command.RequestDto.PostalCode, command.RequestDto.Country);
 
@@ -569,21 +495,11 @@ public async Task<Result> AddMerchantContact(MerchantCommands.AddMerchantContact
         {
             try
             {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result =
-                    this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result stateResult = merchantAggregate.AddContact(command.RequestDto.ContactName,
                                                                  command.RequestDto.PhoneNumber,
@@ -606,20 +522,11 @@ public async Task<Result> AddMerchantContact(MerchantCommands.AddMerchantContact
         public async Task<Result> UpdateMerchantContact(MerchantCommands.UpdateMerchantContactCommand command,
                                                         CancellationToken cancellationToken) {
             try {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result stateResult = merchantAggregate.UpdateContact(command.ContactId, command.RequestDto.ContactName, command.RequestDto.EmailAddress, command.RequestDto.PhoneNumber);
                 if (stateResult.IsFailed)
@@ -639,20 +546,11 @@ public async Task<Result> UpdateMerchantContact(MerchantCommands.UpdateMerchantC
         public async Task<Result> RemoveOperatorFromMerchant(MerchantCommands.RemoveOperatorFromMerchantCommand command, CancellationToken cancellationToken)
         {
             try {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result stateResult = merchantAggregate.RemoveOperator(command.OperatorId);
                 if (stateResult.IsFailed)
@@ -673,21 +571,11 @@ public async Task<Result> RemoveContractFromMerchant(MerchantCommands.RemoveMerc
         {
             try
             {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
-
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result result =
-                    this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result stateResult = merchantAggregate.RemoveContract(command.ContractId);
                 if (stateResult.IsFailed)
@@ -709,21 +597,11 @@ public async Task<Result> UpdateMerchantOpeningHours(MerchantCommands.UpdateMerc
                                                               CancellationToken cancellationToken) {
             try
             {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
-
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result result =
-                    this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
                 var dayMappings = new List<(DayOfWeek Day, TransactionProcessor.DataTransferObjects.Requests.Merchant.OpeningHours Hours)>() {
                     (DayOfWeek.Monday, command.RequestDto.Monday),
                     (DayOfWeek.Tuesday, command.RequestDto.Tuesday),
@@ -756,20 +634,9 @@ public async Task<Result> UpdateMerchantOpeningHours(MerchantCommands.UpdateMerc
         public async Task<Result> CreateMerchantSchedule(MerchantCommands.CreateMerchantScheduleCommand command,
                                                          CancellationToken cancellationToken) {
             try {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
-
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
                 Guid merchantScheduleId = IdGenerationService.GenerateMerchantScheduleAggregateId(command.EstateId, command.MerchantId, command.RequestDto.Year);
                 Result<MerchantScheduleAggregate> merchantScheduleResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantScheduleAggregate>(merchantScheduleId, ct), merchantScheduleId, cancellationToken, false);
@@ -795,20 +662,9 @@ public async Task<Result> CreateMerchantSchedule(MerchantCommands.CreateMerchant
         public async Task<Result> UpdateMerchantSchedule(MerchantCommands.UpdateMerchantScheduleCommand command,
                                                          CancellationToken cancellationToken) {
             try {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
-
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
-
-                Result result = this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
                 Guid merchantScheduleId = IdGenerationService.GenerateMerchantScheduleAggregateId(command.EstateId, command.MerchantId, command.Year);
                 Result<MerchantScheduleAggregate> merchantScheduleResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantScheduleAggregate>(merchantScheduleId, ct), merchantScheduleId, cancellationToken, false);
@@ -840,6 +696,32 @@ private Result ApplyOpeningHoursIfPresent(MerchantAggregate merchantAggregate, D
             return merchantAggregate.SetDayOpeningHours(day, hours.Opening, hours.Closing);
         }
 
+        private sealed record ValidatedMerchantContext(EstateAggregate EstateAggregate,
+                                                       MerchantAggregate MerchantAggregate);
+
+        private async Task<Result<ValidatedMerchantContext>> GetValidatedMerchantContext(Guid estateId,
+                                                                                         Guid merchantId,
+                                                                                         CancellationToken cancellationToken,
+                                                                                         Boolean useLatestMerchant = true) {
+            Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(estateId, ct), estateId, cancellationToken);
+            if (estateResult.IsFailed)
+                return ResultHelpers.CreateFailure(estateResult);
+
+            Func<CancellationToken, Task<Result<MerchantAggregate>>> getMerchant = useLatestMerchant
+                ? ct => this.AggregateService.GetLatest<MerchantAggregate>(merchantId, ct)
+                : ct => this.AggregateService.Get<MerchantAggregate>(merchantId, ct);
+
+            Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(getMerchant, merchantId, cancellationToken);
+            if (merchantResult.IsFailed)
+                return ResultHelpers.CreateFailure(merchantResult);
+
+            Result validateResult = this.ValidateEstateAndMerchant(estateResult.Data, merchantResult.Data);
+            if (validateResult.IsFailed)
+                return ResultHelpers.CreateFailure(validateResult);
+
+            return Result.Success(new ValidatedMerchantContext(estateResult.Data, merchantResult.Data));
+        }
+
         private Result ValidateEstateAndMerchant(EstateAggregate estateAggregate,
                                                  MerchantAggregate merchantAggregate) {
 
@@ -896,17 +778,9 @@ private async Task<Result<MerchantDepositListAggregate>> GetOrCreateMerchantDepo
         private async Task<Result<MerchantDepositListAggregate>> GetMerchantDepositListForWithdrawal(MerchantCommands.MakeMerchantWithdrawalCommand command,
                                                                                                       CancellationToken cancellationToken)
         {
-            Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-            if (estateResult.IsFailed)
-                return ResultHelpers.CreateFailure(estateResult);
-
-            Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-            if (merchantResult.IsFailed)
-                return ResultHelpers.CreateFailure(merchantResult);
-
-            Result validateResult = this.ValidateEstateAndMerchant(estateResult.Data, merchantResult.Data);
-            if (validateResult.IsFailed)
-                return ResultHelpers.CreateFailure(validateResult);
+            Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken, false);
+            if (contextResult.IsFailed)
+                return ResultHelpers.CreateFailure(contextResult);
 
             Result<MerchantDepositListAggregate> getDepositListResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantDepositListAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
             if (getDepositListResult.IsFailed)
@@ -949,21 +823,11 @@ public async Task<Result> SwapMerchantDevice(MerchantCommands.SwapMerchantDevice
         {
             try
             {
-                Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.Get<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
-                if (estateResult.IsFailed)
-                    return ResultHelpers.CreateFailure(estateResult);
-
-                Result<MerchantAggregate> merchantResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<MerchantAggregate>(command.MerchantId, ct), command.MerchantId, cancellationToken);
-                if (merchantResult.IsFailed)
-                    return ResultHelpers.CreateFailure(merchantResult);
-
-                EstateAggregate estateAggregate = estateResult.Data;
-                MerchantAggregate merchantAggregate = merchantResult.Data;
+                Result<ValidatedMerchantContext> contextResult = await this.GetValidatedMerchantContext(command.EstateId, command.MerchantId, cancellationToken);
+                if (contextResult.IsFailed)
+                    return ResultHelpers.CreateFailure(contextResult);
 
-                Result result =
-                    this.ValidateEstateAndMerchant(estateAggregate, merchantAggregate);
-                if (result.IsFailed)
-                    return ResultHelpers.CreateFailure(result);
+                MerchantAggregate merchantAggregate = contextResult.Data.MerchantAggregate;
 
                 Result stateResult = merchantAggregate.SwapDevice(command.DeviceIdentifier, command.RequestDto.NewDeviceIdentifier);
                 if (stateResult.IsFailed)