diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterService.java
index 6123066c1..695136146 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterService.java
@@ -23,8 +23,10 @@ import ru.spcex.platform.enumeration.RegistryStatus;
 import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.util.Collection;
 import java.util.Map;
@@ -42,10 +44,12 @@ public class AdmittedLiabilitiesRegisterService extends QueueConsumer implements
     private final Imdg<Company> companyMap;
     private final Imdg<Security> securityMap;
     private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
+
     @Autowired
     public AdmittedLiabilitiesRegisterService(Consumer<String, Object> kafkaQueue,
                                               Producer<String, Object> kafkaProducer,
-                                              ImdgProvider imdgProvider, Function<Map<String, ?>, IValidator> fieldValuesValidator) {
+                                              ImdgProvider imdgProvider,
+                                              Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.admittedLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister, AdmittedLiabilitiesRegister.class);
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
@@ -126,6 +130,11 @@ public class AdmittedLiabilitiesRegisterService extends QueueConsumer implements
     @Override
     public Optional<AdmittedLiabilitiesRegister> isDuplicateInMap(Registry entity) {
         Map<String, ? extends Comparable<?>> fieldValues = Map.of("companyId", entity.getCompanyId(), "sessionId", entity.getSessionId());
+        Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
         return Optional.ofNullable(admittedLiabilitiesRegisterMap.getFirstObjectByFieldValues(fieldValues));
 
     }
diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterService.java
index 579f0fe33..1b402c147 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterService.java
@@ -23,11 +23,15 @@ import ru.spcex.platform.enumeration.RegistryStatus;
 import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import static ru.spcex.platform.enumeration.Task.createRegistry_CDLR;
 
@@ -39,16 +43,19 @@ public class CoveredLiabilitiesRegisterService extends QueueConsumer implements
     private final Imdg<Registry> registryMap;
     private final Imdg<Company> companyMap;
     private final Imdg<Security> securityMap;
+    private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
     public CoveredLiabilitiesRegisterService(Consumer<String, Object> kafkaQueue,
                                              Producer<String, Object> kafkaProducer,
-                                             ImdgProvider imdgProvider) {
+                                             ImdgProvider imdgProvider,
+                                             Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.coveredLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CoveredLiabilitiesRegister, CoveredLiabilitiesRegister.class);
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.securityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        this.fieldValuesValidator = fieldValuesValidator;
     }
 
     @Override
@@ -72,7 +79,7 @@ public class CoveredLiabilitiesRegisterService extends QueueConsumer implements
             return;
         }
         registries.forEach((registry -> {
-           if (isDuplicateInMap(registry).isEmpty()) {
+            if (isDuplicateInMap(registry).isEmpty()) {
                 insertCoveredLiabilitiesRegister(registry);
             }
         }
@@ -118,6 +125,11 @@ public class CoveredLiabilitiesRegisterService extends QueueConsumer implements
     @Override
     public Optional<CoveredLiabilitiesRegister> isDuplicateInMap(Registry entity) {
         Map<String, ? extends Comparable<?>> fieldValues = Map.of("companyId", entity.getCompanyId(), "sessionId", entity.getSessionId());
-        return  Optional.ofNullable(coveredLiabilitiesRegisterMap.getFirstObjectByFieldValues(fieldValues));
+        Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
+        return Optional.ofNullable(coveredLiabilitiesRegisterMap.getFirstObjectByFieldValues(fieldValues));
     }
 }
diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterService.java
index 962525c12..6caaa8f23 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterService.java
@@ -19,11 +19,15 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import static ru.spcex.platform.enumeration.Task.createRegistry_GRRT;
 
@@ -33,14 +37,17 @@ public class DepoBalanceRegisterService extends QueueConsumer implements Initial
 
     private final Imdg<DepoBalanceRegister> depoBalanceRegisterMap;
     private final Imdg<Registry> registryMap;
+    private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
     public DepoBalanceRegisterService(Consumer<String, Object> kafkaQueue,
                                       Producer<String, Object> kafkaProducer,
-                                      ImdgProvider imdgProvider) {
+                                      ImdgProvider imdgProvider,
+                                      Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.depoBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoBalanceRegister, DepoBalanceRegister.class);
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        this.fieldValuesValidator = fieldValuesValidator;
     }
 
     @Override
@@ -101,6 +108,11 @@ public class DepoBalanceRegisterService extends QueueConsumer implements Initial
     @Override
     public Optional<DepoBalanceRegister> isDuplicateInMap(Registry entity) {
         Map<String, ? extends Comparable<?>> fieldValues = Map.of("companyId", entity.getCompanyId(), "sessionId", entity.getSessionId());
+        Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
         return Optional.ofNullable(depoBalanceRegisterMap.getFirstObjectByFieldValues(fieldValues));
     }
 }
\ No newline at end of file
diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterService.java
index ecc16fe9a..b9a68b62e 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterService.java
@@ -18,11 +18,15 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandR
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import static ru.spcex.platform.enumeration.Task.createRegistry_GORD;
 import static ru.spcex.platform.enumeration.Task.createRegistry_GORR;
@@ -36,17 +40,20 @@ public class DepoPaymentInstructionRegisterService extends QueueConsumer impleme
     private final Imdg<Session> sessionMap;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryMap;
     private final Imdg<InOutDirectionDictionary> InOutDirectionDictionaryMap;
+    private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
     public DepoPaymentInstructionRegisterService(Consumer<String, Object> kafkaQueue,
                                                  Producer<String, Object> kafkaProducer,
-                                                 ImdgProvider imdgProvider) {
+                                                 ImdgProvider imdgProvider,
+                                                 Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.depoPaymentInstructionRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoPaymentInstructionRegister, DepoPaymentInstructionRegister.class);
         this.paymentInstructionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
         this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
         this.tradingClearingRegistryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
         this.InOutDirectionDictionaryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_InOutDirectionDictionary, InOutDirectionDictionary.class);
+        this.fieldValuesValidator = fieldValuesValidator;
     }
 
     @Override
@@ -101,9 +108,15 @@ public class DepoPaymentInstructionRegisterService extends QueueConsumer impleme
 
     @Override
     public Optional<DepoPaymentInstructionRegister> isDuplicateInMap(PaymentInstruction entity) {
-        return Optional.ofNullable(depoPaymentInstructionRegisterMap.getFirstObjectByFieldValues(Map.of(
+        Map<String, ? extends Comparable<?>> fieldValues = Map.of(
                 "companyId", entity.getSenderId(),
-                "sessionId", entity.getSessionId())
-        ));
+                "sessionId", entity.getSessionId()
+        );
+        Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
+        return Optional.ofNullable(depoPaymentInstructionRegisterMap.getFirstObjectByFieldValues(fieldValues);
     }
 }
diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterService.java
index 59079372d..e5fd393f6 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterService.java
@@ -20,13 +20,17 @@ import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.time.TimeUtil;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import static ru.spcex.platform.enumeration.Task.createRegistry_EXLR;
 
@@ -39,17 +43,20 @@ public class ExcludeLiabilitiesRegisterService extends QueueConsumer implements
     private final Imdg<Session> sessionMap;
     private final Imdg<ru.clearing.classes.statics.data.company.CompanySymbols> companySymbolMap;
     private final Imdg<MoneyMarketSecurity> moneyMarketSecurityMap;
+    private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
     public ExcludeLiabilitiesRegisterService(Consumer<String, Object> kafkaQueue,
                                              Producer<String, Object> kafkaProducer,
-                                             ImdgProvider imdgProvider) {
+                                             ImdgProvider imdgProvider,
+                                             Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.excludeLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class);
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
         this.companySymbolMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, ru.clearing.classes.statics.data.company.CompanySymbols.class);
         this.moneyMarketSecurityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
+        this.fieldValuesValidator = fieldValuesValidator;
     }
 
     @Override
@@ -124,6 +131,11 @@ public class ExcludeLiabilitiesRegisterService extends QueueConsumer implements
     @Override
     public Optional<ExcludeLiabilitiesRegister> isDuplicateInMap(Registry entity) {
         Map<String, ? extends Comparable<?>> fieldValues = Map.of("companyId", entity.getCompanyId(), "sessionId", entity.getSessionId());
+        Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
         return Optional.ofNullable(excludeLiabilitiesRegisterMap.getFirstObjectByFieldValues(fieldValues));
     }
 }
diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExecutionRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExecutionRegisterService.java
index 64485ba54..59b30cc16 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExecutionRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExecutionRegisterService.java
@@ -22,12 +22,16 @@ import ru.spcex.platform.enumeration.CompanySymbol;
 import ru.spcex.platform.enumeration.MoneyFlowSide;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import static ru.spcex.clearing.imdg.IMDGDistributedNames.*;
 import static ru.spcex.platform.enumeration.Task.createRegistry_ECNR;
@@ -41,18 +45,20 @@ public class ExecutionRegisterService extends QueueConsumer implements Initializ
     private final Imdg<ExecutionFond> executionFondMap;
     private final Imdg<ExecutionDeposit> executionDepositMap;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryMap;
-
+    private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
     public ExecutionRegisterService(Consumer<String, Object> kafkaQueue,
                                     Producer<String, Object> kafkaProducer,
-                                    ImdgProvider imdgProvider) {
+                                    ImdgProvider imdgProvider,
+                                    Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.executionRegisterMap = imdgProvider.getImdg(Map_ExecutionRegister, ExecutionRegister.class);
         this.companySymbolsMap = imdgProvider.getImdg(Map_CompanySymbols, CompanySymbols.class);
         this.executionFondMap = imdgProvider.getImdg(Map_ExecutionFond, ExecutionFond.class);
         this.executionDepositMap = imdgProvider.getImdg(Map_ExecutionDeposit, ExecutionDeposit.class);
         this.tradingClearingRegistryMap = imdgProvider.getImdg(Map_TradingClearingRegistry, TradingClearingRegistry.class);
+        this.fieldValuesValidator = fieldValuesValidator;
     }
 
     @Override
@@ -279,6 +285,11 @@ public class ExecutionRegisterService extends QueueConsumer implements Initializ
     public Optional<ExecutionRegister> isDuplicateInMap(ExecutionCommon entity) {
         Map<String, ? extends Comparable<?>> map = Map.of("exchangeExecutionId", entity.getExchangeExecutionId(),
                 "tradingDate", LocalDate.now()); //clarify timezone
+        Optional<EnumMessage> message = fieldValuesValidator.apply(map).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
         return Optional.ofNullable(executionRegisterMap.getSingleObjectByFieldValues(map));
     }
 
diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterService.java
index c0c1110c6..13814069e 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterService.java
@@ -23,12 +23,16 @@ import ru.spcex.platform.enumeration.RegistryInstrumentType;
 import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.time.TimeUtil;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import static ru.spcex.platform.enumeration.Task.createRegistry_LBSR;
 
@@ -41,17 +45,20 @@ public class LiabilitiesRegisterService extends QueueConsumer implements Initial
     private final Imdg<Session> sessionMap;
     private final Imdg<CompanySymbols> companySymbolsMap;
     private final Imdg<MoneyMarketSecurity> moneyMarketSecurityMap;
+    private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
     public LiabilitiesRegisterService(Consumer<String, Object> kafkaQueue,
                                       Producer<String, Object> kafkaProducer,
-                                      ImdgProvider imdgProvider) {
+                                      ImdgProvider imdgProvider,
+                                      Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.liabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class);
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
         this.companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
         this.moneyMarketSecurityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
+        this.fieldValuesValidator = fieldValuesValidator;
     }
 
     @Override
@@ -144,6 +151,11 @@ public class LiabilitiesRegisterService extends QueueConsumer implements Initial
     @Override
     public Optional<LiabilitiesRegister> isDuplicateInMap(Registry entity) {
         Map<String, ? extends Comparable<?>> fieldValues = Map.of("companyId", entity.getCompanyId(), "sessionId", entity.getSessionId());
+        Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
         return Optional.ofNullable(liabilitiesRegisterMap.getFirstObjectByFieldValues(fieldValues));
     }
 }
diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterService.java
index e5830768b..4e3f4ac09 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterService.java
@@ -22,11 +22,15 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import static ru.spcex.platform.enumeration.Task.createRegistry_GBRR;
 
@@ -39,17 +43,20 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
     private final Imdg<CompanySymbols> companySymbolsMap;
     private final Imdg<Company> companyMap;
     private final Imdg<Account> accountMap;
+    private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
     public MoneyBalanceRegisterService(Consumer<String, Object> kafkaQueue,
                                        Producer<String, Object> kafkaProducer,
-                                       ImdgProvider imdgProvider) {
+                                       ImdgProvider imdgProvider,
+                                       Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.moneyBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class);
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
         this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        this.fieldValuesValidator = fieldValuesValidator;
     }
 
     @Override
@@ -170,6 +177,11 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
                 "sessionId",
                 entity.getSessionId()
         );
+        Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
         return Optional.ofNullable(moneyBalanceRegisterMap.getFirstObjectByFieldValues(fieldValues));
     }
 }
diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterService.java
index 50cb714d9..825e12950 100644
--- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterService.java
+++ b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterService.java
@@ -16,11 +16,15 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandR
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidator;
 
+import java.text.MessageFormat;
 import java.time.Instant;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 import static ru.spcex.platform.enumeration.Task.createRegistry_GORR;
 
@@ -31,15 +35,18 @@ public class MoneyPaymentInstructionRegisterService extends QueueConsumer implem
     private final Imdg<MoneyPaymentInstructionRegister> moneyPaymentInstructionRegisterMap;
     private final Imdg<PaymentInstruction> paymentInstructionMap;
     private final Imdg<Session> sessionMap;
+    private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
     public MoneyPaymentInstructionRegisterService(Consumer<String, Object> kafkaQueue,
                                                   Producer<String, Object> kafkaProducer,
-                                                  ImdgProvider imdgProvider) {
+                                                  ImdgProvider imdgProvider,
+                                                  Function<Map<String, ?>, IValidator> fieldValuesValidator) {
         super(kafkaQueue, kafkaProducer);
         this.moneyPaymentInstructionRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister, MoneyPaymentInstructionRegister.class);
         this.paymentInstructionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
         this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
+        this.fieldValuesValidator = fieldValuesValidator;
     }
 
     @Override
@@ -86,6 +93,11 @@ public class MoneyPaymentInstructionRegisterService extends QueueConsumer implem
     @Override
     public Optional<MoneyPaymentInstructionRegister> isDuplicateInMap(PaymentInstruction entity) {
         Map<String, ? extends Comparable<?>> fieldValuesCompanyIdSessionId = Map.of("senderId", entity.getSenderId(), "date", entity.getClearingDate());
+        Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValuesCompanyIdSessionId).tillFirstError();
+        if (message.isPresent()) {
+            log.warn("Illegal value in map for request to imdg: {}", message.get());
+            throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
+        }
         return Optional.ofNullable(moneyPaymentInstructionRegisterMap.getFirstObjectByFieldValues(fieldValuesCompanyIdSessionId));
     }
 }