diff --git a/src/ca-module.cpp b/src/ca-module.cpp
index bdb0236..8b8d4bb 100644
--- a/src/ca-module.cpp
+++ b/src/ca-module.cpp
@@ -122,7 +122,7 @@
     const auto& pib = m_keyChain.getPib();
     const auto& identity = pib.getIdentity(m_config.m_caItem.m_caPrefix);
     const auto& cert = identity.getDefaultKey().getDefaultCertificate();
-    Block contentTLV = InfoEncoder::encodeDataContent(m_config.m_caItem, cert);
+    Block contentTLV = infoEncoder::encodeDataContent(m_config.m_caItem, cert);
 
     Name infoPacketName(m_config.m_caItem.m_caPrefix);
     infoPacketName.append("CA").append("INFO").appendVersion().appendSegment(0);
@@ -156,7 +156,7 @@
   NDN_LOG_TRACE("Received PROBE request");
 
   // process PROBE requests: collect probe parameters
-  auto parameters = ProbeEncoder::decodeApplicationParameters(request.getApplicationParameters());
+  auto parameters = probeEncoder::decodeApplicationParameters(request.getApplicationParameters());
   std::vector<PartialName> availableComponents;
   for (auto& item : m_config.m_nameAssignmentFuncs) {
     auto names = item->assignName(parameters);
@@ -176,7 +176,7 @@
 
   Data result;
   result.setName(request.getName());
-  result.setContent(ProbeEncoder::encodeDataContent(availableNames, m_config.m_caItem.m_maxSuffixLength, m_config.m_redirection));
+  result.setContent(probeEncoder::encodeDataContent(availableNames, m_config.m_caItem.m_maxSuffixLength, m_config.m_redirection));
   result.setFreshnessPeriod(DEFAULT_DATA_FRESHNESS_PERIOD);
   m_keyChain.sign(result, signingByIdentity(m_config.m_caItem.m_caPrefix));
   m_face.put(result);
@@ -193,7 +193,7 @@
   std::vector<uint8_t> ecdhPub;
   shared_ptr<security::Certificate> clientCert;
   try {
-    NewRenewRevokeEncoder::decodeApplicationParameters(parameterTLV, requestType, ecdhPub, clientCert);
+    newRenewRevokeEncoder::decodeApplicationParameters(parameterTLV, requestType, ecdhPub, clientCert);
   }
   catch (const std::exception& e) {
     if (!parameterTLV.hasValue()) {
@@ -320,7 +320,7 @@
   Data result;
   result.setName(request.getName());
   result.setFreshnessPeriod(DEFAULT_DATA_FRESHNESS_PERIOD);
-  result.setContent(NewRenewRevokeEncoder::encodeDataContent(myEcdhPubKeyBase64,
+  result.setContent(newRenewRevokeEncoder::encodeDataContent(myEcdhPubKeyBase64,
                                                              salt,
                                                              requestState.m_requestId, requestState.m_status,
                                                              m_config.m_caItem.m_supportedChallenges));
@@ -401,20 +401,20 @@
       requestState->m_status = Status::SUCCESS;
       m_storage->deleteRequest(requestState->m_requestId);
 
-      payload = ChallengeEncoder::encodeDataContent(*requestState, issuedCert.getName());
+      payload = challengeEncoder::encodeDataContent(*requestState, issuedCert.getName());
       NDN_LOG_TRACE("Challenge succeeded. Certificate has been issued: " << issuedCert.getName());
     }
     else if (requestState->m_requestType == RequestType::REVOKE) {
       requestState->m_status = Status::SUCCESS;
       m_storage->deleteRequest(requestState->m_requestId);
 
-      payload = ChallengeEncoder::encodeDataContent(*requestState);
+      payload = challengeEncoder::encodeDataContent(*requestState);
       NDN_LOG_TRACE("Challenge succeeded. Certificate has been revoked");
     }
   }
   else {
     m_storage->updateRequest(*requestState);
-    payload = ChallengeEncoder::encodeDataContent(*requestState);
+    payload = challengeEncoder::encodeDataContent(*requestState);
     NDN_LOG_TRACE("No failure no success. Challenge moves on");
   }
 
@@ -485,7 +485,7 @@
   Data result;
   result.setName(name);
   result.setFreshnessPeriod(DEFAULT_DATA_FRESHNESS_PERIOD);
-  result.setContent(ErrorEncoder::encodeDataContent(error, errorInfo));
+  result.setContent(errorEncoder::encodeDataContent(error, errorInfo));
   m_keyChain.sign(result, signingByIdentity(m_config.m_caItem.m_caPrefix));
   return result;
 }
diff --git a/src/detail/challenge-encoder.cpp b/src/detail/challenge-encoder.cpp
index c9fa34b..6d68869 100644
--- a/src/detail/challenge-encoder.cpp
+++ b/src/detail/challenge-encoder.cpp
@@ -24,7 +24,7 @@
 namespace ndncert {
 
 Block
-ChallengeEncoder::encodeDataContent(ca::RequestState& request, const Name& issuedCertName)
+challengeEncoder::encodeDataContent(ca::RequestState& request, const Name& issuedCertName)
 {
   Block response = makeEmptyBlock(tlv::EncryptedPayload);
   response.push_back(makeNonNegativeIntegerBlock(tlv::Status, static_cast<uint64_t>(request.m_status)));
@@ -45,7 +45,7 @@
 }
 
 void
-ChallengeEncoder::decodeDataContent(const Block& contentBlock, requester::RequestState& state)
+challengeEncoder::decodeDataContent(const Block& contentBlock, requester::RequestState& state)
 {
   auto result = decodeBlockWithAesGcm128(contentBlock, state.m_aesKey.data(),
                                          state.m_requestId.data(), state.m_requestId.size());
diff --git a/src/detail/challenge-encoder.hpp b/src/detail/challenge-encoder.hpp
index 4aa3b5a..0ef68c3 100644
--- a/src/detail/challenge-encoder.hpp
+++ b/src/detail/challenge-encoder.hpp
@@ -26,17 +26,15 @@
 
 namespace ndn {
 namespace ndncert {
+namespace challengeEncoder {
 
-class ChallengeEncoder
-{
-public:
-  static Block
+  Block
   encodeDataContent(ca::RequestState& request, const Name& issuedCertName = Name());
 
-  static void
+  void
   decodeDataContent(const Block& contentBlock, requester::RequestState& state);
-};
 
+} // namespace ChallengeEncoder
 } // namespace ndncert
 } // namespace ndn
 
diff --git a/src/detail/error-encoder.cpp b/src/detail/error-encoder.cpp
index 72b85c5..8d30103 100644
--- a/src/detail/error-encoder.cpp
+++ b/src/detail/error-encoder.cpp
@@ -24,7 +24,7 @@
 namespace ndncert {
 
 Block
-ErrorEncoder::encodeDataContent(ErrorCode errorCode, const std::string& description)
+errorEncoder::encodeDataContent(ErrorCode errorCode, const std::string& description)
 {
   Block response = makeEmptyBlock(ndn::tlv::Content);
   response.push_back(makeNonNegativeIntegerBlock(tlv::ErrorCode, static_cast<size_t>(errorCode)));
@@ -34,7 +34,7 @@
 }
 
 std::tuple<ErrorCode, std::string>
-ErrorEncoder::decodefromDataContent(const Block& block)
+errorEncoder::decodefromDataContent(const Block& block)
 {
   block.parse();
   if (block.find(tlv::ErrorCode) == block.elements_end()) {
diff --git a/src/detail/error-encoder.hpp b/src/detail/error-encoder.hpp
index 6d60462..d8f6ea4 100644
--- a/src/detail/error-encoder.hpp
+++ b/src/detail/error-encoder.hpp
@@ -25,23 +25,21 @@
 
 namespace ndn {
 namespace ndncert {
+namespace errorEncoder {
 
-class ErrorEncoder
-{
-public:
   /**
    * Encode error information into a Data content TLV
    */
-  static Block
+  Block
   encodeDataContent(ErrorCode errorCode, const std::string& description);
 
   /**
    * Decode error information from Data content TLV
    */
-  static std::tuple<ErrorCode, std::string>
+  std::tuple<ErrorCode, std::string>
   decodefromDataContent(const Block& block);
-};
 
+} // namespace ErrorEncoder
 } // namespace ndncert
 } // namespace ndn
 
diff --git a/src/detail/info-encoder.cpp b/src/detail/info-encoder.cpp
index 8a40bd7..0a26f8a 100644
--- a/src/detail/info-encoder.cpp
+++ b/src/detail/info-encoder.cpp
@@ -24,7 +24,7 @@
 namespace ndncert {
 
 Block
-InfoEncoder::encodeDataContent(const CaProfile& caConfig, const security::Certificate& certificate)
+infoEncoder::encodeDataContent(const CaProfile& caConfig, const security::Certificate& certificate)
 {
   auto content = makeEmptyBlock(ndn::tlv::Content);
   content.push_back(makeNestedBlock(tlv::CaPrefix, caConfig.m_caPrefix));
@@ -46,7 +46,7 @@
 }
 
 CaProfile
-InfoEncoder::decodeDataContent(const Block& block)
+infoEncoder::decodeDataContent(const Block& block)
 {
   CaProfile result;
   block.parse();
diff --git a/src/detail/info-encoder.hpp b/src/detail/info-encoder.hpp
index 93e4d97..48a1d82 100644
--- a/src/detail/info-encoder.hpp
+++ b/src/detail/info-encoder.hpp
@@ -25,23 +25,20 @@
 
 namespace ndn {
 namespace ndncert {
-
-class InfoEncoder
-{
-public:
+namespace infoEncoder {
   /**
    * Encode CA configuration and its certificate into a TLV block as INFO Data packet content.
    */
-  static Block
+  Block
   encodeDataContent(const CaProfile& caConfig, const security::Certificate& certificate);
 
   /**
    * Decode CA configuration from the TLV block of INFO Data packet content.
    */
-  static CaProfile
+  CaProfile
   decodeDataContent(const Block& block);
-};
 
+} // namespace InfoEncoder
 } // namespace ndncert
 } // namespace ndn
 
diff --git a/src/detail/new-renew-revoke-encoder.cpp b/src/detail/new-renew-revoke-encoder.cpp
index fd4f48c..0863d9b 100644
--- a/src/detail/new-renew-revoke-encoder.cpp
+++ b/src/detail/new-renew-revoke-encoder.cpp
@@ -29,7 +29,7 @@
 NDN_LOG_INIT(ndncert.encoding.new_renew_revoke);
 
 Block
-NewRenewRevokeEncoder::encodeApplicationParameters(RequestType requestType, const std::vector<uint8_t>& ecdhPub,
+newRenewRevokeEncoder::encodeApplicationParameters(RequestType requestType, const std::vector<uint8_t>& ecdhPub,
                                                    const security::Certificate& certRequest)
 {
   Block request = makeEmptyBlock(ndn::tlv::ApplicationParameters);
@@ -56,7 +56,7 @@
 }
 
 void
-NewRenewRevokeEncoder::decodeApplicationParameters(const Block& payload, RequestType requestType,
+newRenewRevokeEncoder::decodeApplicationParameters(const Block& payload, RequestType requestType,
                                                    std::vector<uint8_t>& ecdhPub,
                                                    shared_ptr<security::Certificate>& clientCert)
 {
@@ -80,7 +80,7 @@
 }
 
 Block
-NewRenewRevokeEncoder::encodeDataContent(const std::vector<uint8_t>& ecdhKey, const std::array<uint8_t, 32>& salt,
+newRenewRevokeEncoder::encodeDataContent(const std::vector<uint8_t>& ecdhKey, const std::array<uint8_t, 32>& salt,
                                          const RequestId& requestId, const Status& status,
                                          const std::list<std::string>& challenges)
 {
@@ -97,7 +97,7 @@
 }
 
 std::list<std::string>
-NewRenewRevokeEncoder::decodeDataContent(const Block& content, std::vector<uint8_t>& ecdhKey,
+newRenewRevokeEncoder::decodeDataContent(const Block& content, std::vector<uint8_t>& ecdhKey,
                                          std::array<uint8_t, 32>& salt, RequestId& requestId, Status& status)
 {
   content.parse();
diff --git a/src/detail/new-renew-revoke-encoder.hpp b/src/detail/new-renew-revoke-encoder.hpp
index 9803a57..c70404c 100644
--- a/src/detail/new-renew-revoke-encoder.hpp
+++ b/src/detail/new-renew-revoke-encoder.hpp
@@ -25,28 +25,26 @@
 
 namespace ndn {
 namespace ndncert {
+namespace newRenewRevokeEncoder {
 
-class NewRenewRevokeEncoder
-{
-public:
-  static Block
+  Block
   encodeApplicationParameters(RequestType requestType, const std::vector<uint8_t>& ecdhPub,
                               const security::Certificate& certRequest);
 
-  static void
+  void
   decodeApplicationParameters(const Block& block, RequestType requestType, std::vector<uint8_t>& ecdhPub,
                               shared_ptr<security::Certificate>& certRequest);
 
-  static Block
+  Block
   encodeDataContent(const std::vector<uint8_t>& ecdhKey, const std::array<uint8_t, 32>& salt,
                     const RequestId& requestId, const Status& status,
                     const std::list<std::string>& challenges);
 
-  static std::list<std::string>
+  std::list<std::string>
   decodeDataContent(const Block& content, std::vector<uint8_t>& ecdhKey,
                     std::array<uint8_t, 32>& salt, RequestId& requestId, Status& status);
-};
 
+} // namespace NewRenewRevokeEncoder
 } // namespace ndncert
 } // namespace ndn
 
diff --git a/src/detail/probe-encoder.cpp b/src/detail/probe-encoder.cpp
index d6798f9..a4271f5 100644
--- a/src/detail/probe-encoder.cpp
+++ b/src/detail/probe-encoder.cpp
@@ -24,7 +24,7 @@
 namespace ndncert {
 
 Block
-ProbeEncoder::encodeApplicationParameters(std::vector<std::tuple<std::string, std::string>>&& parameters)
+probeEncoder::encodeApplicationParameters(std::vector<std::tuple<std::string, std::string>>&& parameters)
 {
   auto content = makeEmptyBlock(ndn::tlv::ApplicationParameters);
   for (size_t i = 0; i < parameters.size(); ++i) {
@@ -36,7 +36,7 @@
 }
 
 std::vector<std::tuple<std::string, std::string>>
-ProbeEncoder::decodeApplicationParameters(const Block& block)
+probeEncoder::decodeApplicationParameters(const Block& block)
 {
   std::vector<std::tuple<std::string, std::string>> result;
   block.parse();
@@ -49,8 +49,8 @@
 }
 
 Block
-ProbeEncoder::encodeDataContent(const std::vector<Name>& identifiers, optional<size_t> maxSuffixLength,
-                         optional<std::vector<std::shared_ptr<security::Certificate>>> redirectionItems)
+probeEncoder::encodeDataContent(const std::vector<Name>& identifiers, optional<size_t> maxSuffixLength,
+                                optional<std::vector<std::shared_ptr<security::Certificate>>> redirectionItems)
 {
   Block content = makeEmptyBlock(ndn::tlv::Content);
   for (const auto& name : identifiers) {
@@ -71,9 +71,9 @@
 }
 
 void
-ProbeEncoder::decodeDataContent(const Block& block,
-                         std::vector<std::pair<Name, int>>& availableNames,
-                         std::vector<Name>& availableRedirection)
+probeEncoder::decodeDataContent(const Block& block,
+                                std::vector<std::pair<Name, int>>& availableNames,
+                                std::vector<Name>& availableRedirection)
 {
   block.parse();
   for (const auto& item : block.elements()) {
diff --git a/src/detail/probe-encoder.hpp b/src/detail/probe-encoder.hpp
index 0a991c3..03d216e 100644
--- a/src/detail/probe-encoder.hpp
+++ b/src/detail/probe-encoder.hpp
@@ -25,28 +25,25 @@
 
 namespace ndn {
 namespace ndncert {
+namespace probeEncoder {
 
-class ProbeEncoder
-{
-public:
   // For Client use
-  static Block
+  Block
   encodeApplicationParameters(std::vector<std::tuple<std::string, std::string>>&& parameters);
 
-  static void
+  void
   decodeDataContent(const Block& block, std::vector<std::pair<Name, int>>& availableNames,
                     std::vector<Name>& availableRedirection);
 
   // For CA use
-  static Block
+  Block
   encodeDataContent(const std::vector<Name>& identifiers,
                     optional<size_t> maxSuffixLength = nullopt,
                     optional<std::vector<std::shared_ptr<security::Certificate>>> redirectionItems = nullopt);
 
-  static std::vector<std::tuple<std::string, std::string>>
+  std::vector<std::tuple<std::string, std::string>>
   decodeApplicationParameters(const Block& block);
-};
-
+} // namespace ProbeEncoder
 } // namespace ndncert
 } // namespace ndn
 
diff --git a/src/requester.cpp b/src/requester.cpp
index ef839c0..7ace36c 100644
--- a/src/requester.cpp
+++ b/src/requester.cpp
@@ -66,7 +66,7 @@
 optional<CaProfile>
 Requester::onCaProfileResponse(const Data& reply)
 {
-  auto caItem = InfoEncoder::decodeDataContent(reply.getContent());
+  auto caItem = infoEncoder::decodeDataContent(reply.getContent());
   if (!security::verifySignature(reply, *caItem.m_cert)) {
     NDN_LOG_ERROR("Cannot verify replied Data packet signature.");
     NDN_THROW(std::runtime_error("Cannot verify replied Data packet signature."));
@@ -77,7 +77,7 @@
 optional<CaProfile>
 Requester::onCaProfileResponseAfterRedirection(const Data& reply, const Name& caCertFullName)
 {
-  auto caItem = InfoEncoder::decodeDataContent(reply.getContent());
+  auto caItem = infoEncoder::decodeDataContent(reply.getContent());
   auto certBlock = caItem.m_cert->wireEncode();
   caItem.m_cert = std::make_shared<security::Certificate>(certBlock);
   if (caItem.m_cert->getFullName() != caCertFullName) {
@@ -95,7 +95,7 @@
   auto interest =std::make_shared<Interest>(interestName);
   interest->setMustBeFresh(true);
   interest->setCanBePrefix(false);
-  interest->setApplicationParameters(ProbeEncoder::encodeApplicationParameters(std::move(probeInfo)));
+  interest->setApplicationParameters(probeEncoder::encodeApplicationParameters(std::move(probeInfo)));
   return interest;
 }
 
@@ -109,7 +109,7 @@
     return;
   }
   processIfError(reply);
-  ProbeEncoder::decodeDataContent(reply.getContent(), identityNames, otherCas);
+  probeEncoder::decodeDataContent(reply.getContent(), identityNames, otherCas);
 }
 
 shared_ptr<Interest>
@@ -165,7 +165,7 @@
   interest->setMustBeFresh(true);
   interest->setCanBePrefix(false);
   interest->setApplicationParameters(
-      NewRenewRevokeEncoder::encodeApplicationParameters(RequestType::NEW, state.m_ecdh.getSelfPubKey(), certRequest));
+          newRenewRevokeEncoder::encodeApplicationParameters(RequestType::NEW, state.m_ecdh.getSelfPubKey(), certRequest));
 
   // sign the Interest packet
   state.m_keyChain.sign(*interest, signingByKey(keyName));
@@ -185,7 +185,7 @@
   interest->setMustBeFresh(true);
   interest->setCanBePrefix(false);
   interest->setApplicationParameters(
-      NewRenewRevokeEncoder::encodeApplicationParameters(RequestType::REVOKE, state.m_ecdh.getSelfPubKey(), certificate));
+          newRenewRevokeEncoder::encodeApplicationParameters(RequestType::REVOKE, state.m_ecdh.getSelfPubKey(), certificate));
   return interest;
 }
 
@@ -201,7 +201,7 @@
   auto contentTLV = reply.getContent();
   std::vector<uint8_t> ecdhKey;
   std::array<uint8_t, 32> salt;
-  auto challenges = NewRenewRevokeEncoder::decodeDataContent(contentTLV, ecdhKey, salt, state.m_requestId, state.m_status);
+  auto challenges = newRenewRevokeEncoder::decodeDataContent(contentTLV, ecdhKey, salt, state.m_requestId, state.m_status);
 
   // ECDH and HKDF
   auto sharedSecret = state.m_ecdh.deriveSecret(ecdhKey);
@@ -261,7 +261,7 @@
     NDN_THROW(std::runtime_error("Cannot verify replied Data packet signature."));
   }
   processIfError(reply);
-  ChallengeEncoder::decodeDataContent(reply.getContent(), state);
+  challengeEncoder::decodeDataContent(reply.getContent(), state);
 }
 
 shared_ptr<Interest>
@@ -309,7 +309,7 @@
 void
 Requester::processIfError(const Data& data)
 {
-  auto errorInfo = ErrorEncoder::decodefromDataContent(data.getContent());
+  auto errorInfo = errorEncoder::decodefromDataContent(data.getContent());
   if (std::get<0>(errorInfo) == ErrorCode::NO_ERROR) {
     return;
   }