diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/errors/SecuritiesError.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/errors/SecuritiesError.java
index 7bffa0a3f..5a64dc08e 100644
--- a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/errors/SecuritiesError.java
+++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/errors/SecuritiesError.java
@@ -8,6 +8,8 @@ public enum SecuritiesError implements IErrorEnumId {
     InstrumentAlreadyExists(1010L),
     InstrumentNotFound(1011L),
     InstrumentNotActive(1012L),
+    CouponPeriodAlreadyExists(1013L),
+    CouponPeriodNotFound(1014L),
     CurrencyAlreadyExists(1015L),
     CurrencyNotFound(1016L),
 
diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CouponPeriodService.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CouponPeriodService.java
new file mode 100644
index 000000000..96e55f284
--- /dev/null
+++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CouponPeriodService.java
@@ -0,0 +1,89 @@
+package ru.spcex.clearing.securities.service.cud;
+
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodUpdateRequest;
+import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.securities.validation.ValidationProvider;
+import ru.spcex.clearing.validation.common.ValidationHelper;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgId;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+@Service
+public class CouponPeriodService extends QueueConsumer implements InitializingBean {
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    private final Imdg<CouponPeriod> couponPeriodImdg;
+    private final ImdgProvider imdgProvider;
+    private final ImdgId idGenerator;
+    private final ValidationProvider validation;
+    private final ValidationHelper validationHelper;
+
+    @Autowired
+    public CouponPeriodService(Consumer<String, Object> kafkaQueue,
+                               Producer<String, Object> kafkaProducer,
+                               ImdgProvider imdgProvider,
+                               ValidationProvider validation,
+                               ValidationHelper validationHelper) {
+        super(kafkaQueue, kafkaProducer);
+        this.validation = validation;
+        this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
+        this.imdgProvider = imdgProvider;
+        this.idGenerator = imdgProvider.getImdgIdGenerator();
+        this.validationHelper = validationHelper;
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        callback(CouponPeriodNewRequest.class)
+                .setFunction(this::newCouponPeriod)
+                .forDestination(Consts.DESTINATION_COUPON_PERIOD_NEW, callbacks::put);
+        callback(CouponPeriodUpdateRequest.class)
+                .setFunction(this::updateCouponPeriod)
+                .forDestination(Consts.DESTINATION_COUPON_PERIOD_UPDATE, callbacks::put);
+        imdgProvider.waitAvailable();
+        init();
+    }
+
+    private RequestInfoUpdate newCouponPeriod(BaseRequest<CouponPeriodNewRequest> userRequest) {
+        CouponPeriodNewRequest req = userRequest.getRequestPayload();
+
+        RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.couponPeriodNewValidator());
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        log.debug("newCurrency received");
+        CouponPeriod couponPeriod = new CouponPeriod();
+        couponPeriod.setId(idGenerator.nextId());
+        couponPeriod.setSecurityId(req.getSecurityId());
+        couponPeriod.setPeriodEndDate(req.getPeriodEndDate());
+        couponPeriod.setPeriodStartDate(req.getPeriodStartDate());
+        couponPeriodImdg.insert(couponPeriod);
+        log.debug("successfully processed, request id {}, new object id {}", userRequest.getId(), couponPeriod.getId());
+        return null; // default success
+    }
+
+    private RequestInfoUpdate updateCouponPeriod(BaseRequest<CouponPeriodUpdateRequest> userRequest) {
+        CouponPeriodUpdateRequest req = userRequest.getRequestPayload();
+        log.debug("updateCurrency received id = {}", req.getId());
+
+        RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.couponPeriodUpdateValidator());
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        CouponPeriod couponPeriod = couponPeriodImdg.getSingleObjectBySQL(String.format("securityId = %s", req.getSecurityId()));
+        couponPeriod.setPeriodEndDate(req.getPeriodEndDate());
+        couponPeriod.setPeriodStartDate(req.getPeriodStartDate());
+        couponPeriodImdg.update(couponPeriod);
+        return null;
+    }
+}
diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyService.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyService.java
index 52e01c60f..8796e8e76 100644
--- a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyService.java
+++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/service/cud/CurrencyService.java
@@ -15,13 +15,11 @@ import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CurrencyNewRe
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CurrencyUpdateRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
-import ru.spcex.clearing.securities.component.ListingBuilder;
 import ru.spcex.clearing.securities.validation.ValidationProvider;
 import ru.spcex.clearing.validation.common.ValidationHelper;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgId;
 import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.imdg.api.ImdgTransaction;
 
 @Service
 public class CurrencyService extends QueueConsumer implements InitializingBean {
@@ -31,7 +29,6 @@ public class CurrencyService extends QueueConsumer implements InitializingBean {
     private final ImdgId idGenerator;
     private final ValidationProvider validation;
     private final ValidationHelper validationHelper;
-    private final ListingBuilder listingBuilder = new ListingBuilder();
 
     @Autowired
     public CurrencyService(Consumer<String, Object> kafkaQueue,
@@ -51,16 +48,15 @@ public class CurrencyService extends QueueConsumer implements InitializingBean {
     public void afterPropertiesSet() {
         callback(CurrencyNewRequest.class)
                 .setFunction(this::newCurrency)
-                .forDestination(Consts.DESTINATION_СURRENCY_NEW, callbacks::put);
+                .forDestination(Consts.DESTINATION_CURRENCY_NEW, callbacks::put);
         callback(CurrencyUpdateRequest.class)
                 .setFunction(this::updateCurrency)
-                .forDestination(Consts.DESTINATION_СURRENCY_UPDATE, callbacks::put);
+                .forDestination(Consts.DESTINATION_CURRENCY_UPDATE, callbacks::put);
         imdgProvider.waitAvailable();
         init();
     }
 
     private RequestInfoUpdate newCurrency(BaseRequest<CurrencyNewRequest> userRequest) {
-        ImdgTransaction transaction = imdgProvider.newTransaction();
         CurrencyNewRequest req = userRequest.getRequestPayload();
 
         RequestInfoUpdate requestInfoUpdate = validationHelper.validateTillFirstError(userRequest, validation.currencyNewValidator());
diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java
index ed7c2f5a5..a8a055fd3 100644
--- a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java
+++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/ValidationProvider.java
@@ -29,6 +29,7 @@ public class ValidationProvider {
     private final Imdg<SpcexObjectBase> bondTypeDictionaryImdg;
     private final Imdg<SpcexObjectBase> companyImdg;
     private final Imdg<SpcexObjectBase> currencyImdg;
+    private final Imdg<SpcexObjectBase> couponPeriodImdg;
 
 
     public ValidationProvider(ImdgProvider imdgProvider) {
@@ -43,6 +44,7 @@ public class ValidationProvider {
         this.bondTypeDictionaryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_BondTypeDictionary, SpcexObjectBase.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, SpcexObjectBase.class);
         this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, SpcexObjectBase.class);
+        this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, SpcexObjectBase.class);
     }
 
     public Function<MoneyMarketSecurityNewRequest, IValidator> mmsNewValidator() {
@@ -241,4 +243,26 @@ public class ValidationProvider {
             );
         };
     }
+
+    public Function<CouponPeriodNewRequest, IValidator> couponPeriodNewValidator() {
+        return currencyRequest -> {
+            ImdgValidationContext<CouponPeriodNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(currencyRequest);
+            context.addImdg(IMDGDistributedNames.Map_CouponPeriod, couponPeriodImdg);
+            return new ValidatorImpl<>(context,
+                    CouponPeriodNewValidationRule.CouponPeriodNotExists
+            );
+        };
+    }
+
+    public Function<CouponPeriodUpdateRequest, IValidator> couponPeriodUpdateValidator() {
+        return currencyRequest -> {
+            ImdgValidationContext<CouponPeriodUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(currencyRequest);
+            context.addImdg(IMDGDistributedNames.Map_CouponPeriod, couponPeriodImdg);
+            return new ValidatorImpl<>(context,
+                    CouponPeriodUpdateValidationRule.CouponPeriodExists
+            );
+        };
+    }
 }
diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/rule/CouponPeriodNewValidationRule.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/rule/CouponPeriodNewValidationRule.java
new file mode 100644
index 000000000..7a95f7298
--- /dev/null
+++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/rule/CouponPeriodNewValidationRule.java
@@ -0,0 +1,48 @@
+package ru.spcex.clearing.securities.validation.rule;
+
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodNewRequest;
+import ru.spcex.clearing.securities.errors.SecuritiesError;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidationRule;
+
+import java.util.Map;
+import java.util.Optional;
+
+public enum CouponPeriodNewValidationRule implements IValidationRule<ImdgValidationContext<CouponPeriodNewRequest>> {
+    CouponPeriodNotExists() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<CouponPeriodNewRequest> context) {
+            CouponPeriodNewRequest action = context.getValidatedObject();
+            if (action.getSecurityId() == null) {
+                return of(SecuritiesError.RequiredFieldIsEmpty, "securityId");
+            }
+            Imdg<SpcexObjectBase> imdgDictionary = context.obtainMap(IMDGDistributedNames.Map_CouponPeriod, SpcexObjectBase.class);
+            SpcexObjectBase couponPeriod = imdgDictionary.getSingleObjectByFieldValues(Map.of(
+                    "securityId", action.getSecurityId()));
+            if (couponPeriod != null) {
+                return of(SecuritiesError.CouponPeriodAlreadyExists, "securityId");
+            }
+            if (action.getPeriodEndDate() == null && action.getPeriodStartDate() == null) {
+                return of(SecuritiesError.RequiredFieldIsEmpty, "periodEndDate", "periodStartDate");
+            }
+            if (action.getPeriodEndDate() == null || action.getPeriodStartDate() == null) {
+                if (action.getPeriodStartDate() == null)
+                    return of(SecuritiesError.RequiredFieldIsEmpty, "periodStartDate");
+                return of(SecuritiesError.RequiredFieldIsEmpty, "periodEndDate");
+            }
+            if (action.getPeriodEndDate().isBefore(action.getPeriodStartDate())) {
+                return of(SecuritiesError.WrongFieldValue, "periodEndDate", "periodStartDate");
+            }
+            return empty();
+        }
+    };
+
+    @Override
+    public String ruleName() {
+        return "MmsNewValidationRule." + name();
+    }
+}
diff --git a/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/rule/CouponPeriodUpdateValidationRule.java b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/rule/CouponPeriodUpdateValidationRule.java
new file mode 100644
index 000000000..9aeb7ffc1
--- /dev/null
+++ b/clearing-parent/securities-service/src/main/java/ru/spcex/clearing/securities/validation/rule/CouponPeriodUpdateValidationRule.java
@@ -0,0 +1,48 @@
+package ru.spcex.clearing.securities.validation.rule;
+
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodUpdateRequest;
+import ru.spcex.clearing.securities.errors.SecuritiesError;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidationRule;
+
+import java.util.Map;
+import java.util.Optional;
+
+public enum CouponPeriodUpdateValidationRule implements IValidationRule<ImdgValidationContext<CouponPeriodUpdateRequest>> {
+    CouponPeriodExists() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<CouponPeriodUpdateRequest> context) {
+            CouponPeriodUpdateRequest action = context.getValidatedObject();
+            if (action.getSecurityId() == null) {
+                return of(SecuritiesError.RequiredFieldIsEmpty, "securityId");
+            }
+            Imdg<SpcexObjectBase> imdgDictionary = context.obtainMap(IMDGDistributedNames.Map_CouponPeriod, SpcexObjectBase.class);
+            SpcexObjectBase currency = imdgDictionary.getSingleObjectByFieldValues(Map.of(
+                    "securityId", action.getSecurityId()));
+            if (currency == null) {
+                return of(SecuritiesError.CouponPeriodNotFound, "securityId");
+            }
+            if (action.getPeriodEndDate() == null && action.getPeriodStartDate() == null) {
+                return of(SecuritiesError.RequiredFieldIsEmpty, "periodEndDate", "periodStartDate");
+            }
+            if (action.getPeriodEndDate() == null || action.getPeriodStartDate() == null) {
+                if (action.getPeriodStartDate() == null)
+                    return of(SecuritiesError.RequiredFieldIsEmpty, "periodStartDate");
+                return of(SecuritiesError.RequiredFieldIsEmpty, "periodEndDate");
+            }
+            if (action.getPeriodEndDate().isBefore(action.getPeriodStartDate())) {
+                return of(SecuritiesError.WrongFieldValue, "periodEndDate", "periodStartDate");
+            }
+            return empty();
+        }
+    };
+
+    @Override
+    public String ruleName() {
+        return "MmsNewValidationRule." + name();
+    }
+}
diff --git a/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/AbstractServiceTest.java b/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/AbstractServiceTest.java
index 4d9943720..e83f7f6cd 100644
--- a/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/AbstractServiceTest.java
+++ b/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/AbstractServiceTest.java
@@ -11,6 +11,7 @@ import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod;
 import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
 import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
 import ru.clearing.classes.statics.data.misc.Currency;
@@ -23,10 +24,7 @@ import ru.spcex.clearing.securities.config.ErrorResolverConfig;
 import ru.spcex.clearing.securities.config.ImdgTestConfig;
 import ru.spcex.clearing.securities.config.KafkaTestConfig;
 import ru.spcex.clearing.securities.config.ValidationConfig;
-import ru.spcex.clearing.securities.service.cud.CurrencyService;
-import ru.spcex.clearing.securities.service.cud.EquitySecurityService;
-import ru.spcex.clearing.securities.service.cud.FixedIncomeSecurityService;
-import ru.spcex.clearing.securities.service.cud.MoneyMarketSecurityService;
+import ru.spcex.clearing.securities.service.cud.*;
 import ru.spcex.clearing.securities.utils.MatcherFactory;
 import ru.spcex.clearing.securities.utils.TestUtils;
 import ru.spcex.clearing.securities.validation.ValidationProvider;
@@ -41,10 +39,11 @@ import static ru.spcex.clearing.securities.utils.MatcherFactory.usingIgnoringFie
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
+        CouponPeriodService.class,
+        CurrencyService.class,
         EquitySecurityService.class,
         FixedIncomeSecurityService.class,
         MoneyMarketSecurityService.class,
-        CurrencyService.class,
         ImdgTestConfig.class,
         KafkaTestConfig.class,
         ValidationProvider.class,
@@ -65,6 +64,7 @@ public abstract class AbstractServiceTest {
     protected Imdg<BondTypeDictionary> bondTypeDictionaryImdg;
     protected Imdg<Company> companyImdg;
     protected Imdg<Currency> currencyImdg;
+    protected Imdg<CouponPeriod> couponPeriodImdg;
 
     public static String RATE = "RATE";
     protected String EQTY = "EQTY";
@@ -97,6 +97,7 @@ public abstract class AbstractServiceTest {
         this.bondTypeDictionaryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_BondTypeDictionary, BondTypeDictionary.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.currencyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Currency, Currency.class);
+        this.couponPeriodImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class);
 
         InstrumentTypeDictionary instrumentTypeDictionary = new InstrumentTypeDictionary();
         instrumentTypeDictionary.setId(1L);
diff --git a/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CouponPeriodServiceTest.java b/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CouponPeriodServiceTest.java
new file mode 100644
index 000000000..295d403b0
--- /dev/null
+++ b/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CouponPeriodServiceTest.java
@@ -0,0 +1,100 @@
+package ru.spcex.clearing.securities.service;
+
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod;
+import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.securitites.CouponPeriodUpdateRequest;
+import ru.spcex.clearing.securities.service.cud.CouponPeriodService;
+import ru.spcex.clearing.securities.utils.MatcherFactory;
+
+import javax.annotation.PostConstruct;
+import java.time.LocalDate;
+
+import static ru.spcex.clearing.securities.utils.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.securities.utils.TestUtils.*;
+
+public class CouponPeriodServiceTest extends AbstractServiceTest {
+    private static final MatcherFactory.Matcher<CouponPeriod> COUPON_PERIOD_MATCHER = usingIgnoringFieldsComparator();
+    private final long ID = currentId.getAndIncrement();
+    private final long securityId = 3123L;
+    private final int PARTITION = 0;
+    private final String countryCode = "countryCode";
+    private final String currencyCode = "currencyCode";
+    @Autowired
+    private CouponPeriodService couponPeriodService;
+
+    @PostConstruct
+    protected void init() {
+        super.init();
+    }
+
+    /**
+     * {@link CouponPeriodService#newCouponPeriod(BaseRequest)}<br>
+     * Тест проверяет генерацию сущности {@link CouponPeriod} в Hazelcast при передаче из Apache Kafka.<br>
+     * Входной запрос {@link CouponPeriodNewRequest}:<br>
+     */
+    @Test
+    public void testNewCurrency() {
+        clearAllInImdg(couponPeriodImdg);
+        final String TOPIC = Consts.DESTINATION_COUPON_PERIOD_NEW;
+
+        final CouponPeriod currencyPrediction = new CouponPeriod();
+        currencyPrediction.setSecurityId(securityId);
+        currencyPrediction.setPeriodEndDate(LocalDate.now());
+        currencyPrediction.setPeriodStartDate(LocalDate.ofEpochDay(0));
+        final CouponPeriodNewRequest request = new CouponPeriodNewRequest();
+        request.setSecurityId(securityId);
+        request.setPeriodEndDate(LocalDate.now());
+        request.setPeriodStartDate(LocalDate.ofEpochDay(0));
+
+
+        //ACT
+        String jsonString = getJsonStringForNew(request, ID);
+
+        addRecordToKafka((MockConsumer) couponPeriodService.getConsumer(), TOPIC, PARTITION, 0, jsonString);
+
+        //ASSERT
+        waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
+
+        CouponPeriod result = couponPeriodImdg.getSingleObjectBySQL(String.format("securityId = %s", currencyPrediction.getSecurityId()));
+        currencyPrediction.setId(result.getId());
+        COUPON_PERIOD_MATCHER.assertMatch(result, currencyPrediction);
+    }
+
+    /**
+     * {@link CouponPeriodService#updateCouponPeriod(BaseRequest)}
+     * Тест проверяет обновление сущности {@link CouponPeriod} в Hazelcast при передаче из Apache Kafka.<br>
+     * Входной запрос {@link CouponPeriodUpdateRequest}:<br>
+     */
+    @Test
+    public void testUpdateCurrency() {
+        clearAllInImdg(couponPeriodImdg);
+        final String TOPIC = Consts.DESTINATION_COUPON_PERIOD_UPDATE;
+        final CouponPeriod currencyPrediction = new CouponPeriod();
+        currencyPrediction.setSecurityId(securityId);
+        currencyPrediction.setPeriodEndDate(LocalDate.ofEpochDay(0));
+        currencyPrediction.setPeriodStartDate(LocalDate.ofEpochDay(0));
+        couponPeriodImdg.insert(currencyPrediction);
+        final CouponPeriodNewRequest request = new CouponPeriodNewRequest();
+        currencyPrediction.setPeriodEndDate(LocalDate.now());
+        request.setSecurityId(securityId);
+        request.setPeriodEndDate(LocalDate.now());
+        request.setPeriodStartDate(LocalDate.ofEpochDay(0));
+
+        //ACT
+        String jsonString = getJsonStringForUPDATE(request, ID);
+
+        addRecordToKafka((MockConsumer) couponPeriodService.getConsumer(), TOPIC, PARTITION, 0, jsonString);
+
+        //ASSERT
+        waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
+
+        CouponPeriod result = couponPeriodImdg.getSingleObjectBySQL(String.format("securityId = %s", currencyPrediction.getSecurityId()));
+        currencyPrediction.setId(result.getId());
+        COUPON_PERIOD_MATCHER.assertMatch(result, currencyPrediction);
+    }
+}
diff --git a/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CurrencyServiceTest.java b/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CurrencyServiceTest.java
index b52eeac72..525074512 100644
--- a/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CurrencyServiceTest.java
+++ b/clearing-parent/securities-service/src/test/java/ru/spcex/clearing/securities/service/CurrencyServiceTest.java
@@ -17,7 +17,7 @@ import static ru.spcex.clearing.securities.utils.MatcherFactory.usingIgnoringFie
 import static ru.spcex.clearing.securities.utils.TestUtils.*;
 
 public class CurrencyServiceTest extends AbstractServiceTest {
-    private static final MatcherFactory.Matcher<Currency> CURRENCY_MATCHER = usingIgnoringFieldsComparator("created", "updated");
+    private static final MatcherFactory.Matcher<Currency> CURRENCY_MATCHER = usingIgnoringFieldsComparator();
     private final long ID = currentId.getAndIncrement();
     private final int PARTITION = 0;
     private final String countryCode = "countryCode";
@@ -38,7 +38,7 @@ public class CurrencyServiceTest extends AbstractServiceTest {
     @Test
     public void testNewCurrency() {
         clearAllInImdg(currencyImdg);
-        final String TOPIC = Consts.DESTINATION_СURRENCY_NEW;
+        final String TOPIC = Consts.DESTINATION_CURRENCY_NEW;
 
         final Currency currencyPrediction = new Currency();
         currencyPrediction.setCountryCode(countryCode);
@@ -68,7 +68,7 @@ public class CurrencyServiceTest extends AbstractServiceTest {
     @Test
     public void testUpdateCurrency() {
         clearAllInImdg(currencyImdg);
-        final String TOPIC = Consts.DESTINATION_СURRENCY_UPDATE;
+        final String TOPIC = Consts.DESTINATION_CURRENCY_UPDATE;
         final Currency currencyPrediction = new Currency();
         currencyPrediction.setId(ID);
         currencyPrediction.setCountryCode("ExistsCountryCode");
diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java
index b4392e713..69bfd494d 100644
--- a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java
+++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/Consts.java
@@ -13,9 +13,10 @@ public interface Consts {
     String DESTINATION_FIXED_INCOME_SECURITY_UPDATE = "fixed-income-security-update";
     String DESTINATION_FIXED_INCOME_SECURITY_DELETE = "fixed-income-security-delete";
 
-    String DESTINATION_СURRENCY_NEW = "currency-new";
-    String DESTINATION_СURRENCY_UPDATE = "currency-update";
-    String DESTINATION_СURRENCY_DELETE = "currency-delete";
+    String DESTINATION_CURRENCY_NEW = "currency-new";
+    String DESTINATION_CURRENCY_UPDATE = "currency-update";
+    String DESTINATION_COUPON_PERIOD_NEW = "coupon_period-new";
+    String DESTINATION_COUPON_PERIOD_UPDATE = "coupon_period-update";
 
     String DESTINATION_KEY_RATE_NEW = "key-rate-new";
     String DESTINATION_KEY_RATE_UPDATE = "key-rate-update";
diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/CouponPeriodNewRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/CouponPeriodNewRequest.java
new file mode 100644
index 000000000..23118e3cb
--- /dev/null
+++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/CouponPeriodNewRequest.java
@@ -0,0 +1,46 @@
+package ru.spcex.clearing.platform.messaging.domain.cud.securitites;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
+import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
+
+import java.time.LocalDate;
+
+public class CouponPeriodNewRequest {
+    @JsonProperty
+    public Long securityId;
+    @JsonProperty
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    public LocalDate periodEndDate;
+    @JsonProperty
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    public LocalDate periodStartDate;
+
+    public Long getSecurityId() {
+        return securityId;
+    }
+
+    public void setSecurityId(Long securityId) {
+        this.securityId = securityId;
+    }
+
+    public LocalDate getPeriodEndDate() {
+        return periodEndDate;
+    }
+
+    public void setPeriodEndDate(LocalDate periodEndDate) {
+        this.periodEndDate = periodEndDate;
+    }
+
+    public LocalDate getPeriodStartDate() {
+        return periodStartDate;
+    }
+
+    public void setPeriodStartDate(LocalDate periodStartDate) {
+        this.periodStartDate = periodStartDate;
+    }
+}
diff --git a/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/CouponPeriodUpdateRequest.java b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/CouponPeriodUpdateRequest.java
new file mode 100644
index 000000000..96a344661
--- /dev/null
+++ b/platform-parent/platform-messaging/src/main/java/ru/spcex/clearing/platform/messaging/domain/cud/securitites/CouponPeriodUpdateRequest.java
@@ -0,0 +1,59 @@
+package ru.spcex.clearing.platform.messaging.domain.cud.securitites;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
+import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
+import ru.spcex.platform.classes.base.interfaces.WithId;
+
+import java.time.LocalDate;
+
+public class CouponPeriodUpdateRequest implements WithId {
+    @JsonProperty
+    public Long id;
+    @JsonProperty
+    public Long securityId;
+    @JsonProperty
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    public LocalDate periodEndDate;
+    @JsonProperty
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    public LocalDate periodStartDate;
+
+
+    @Override
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getSecurityId() {
+        return securityId;
+    }
+
+    public void setSecurityId(Long securityId) {
+        this.securityId = securityId;
+    }
+
+    public LocalDate getPeriodEndDate() {
+        return periodEndDate;
+    }
+
+    public void setPeriodEndDate(LocalDate periodEndDate) {
+        this.periodEndDate = periodEndDate;
+    }
+
+    public LocalDate getPeriodStartDate() {
+        return periodStartDate;
+    }
+
+    public void setPeriodStartDate(LocalDate periodStartDate) {
+        this.periodStartDate = periodStartDate;
+    }
+}