diff --git a/meson.build b/meson.build
index ce77f2a..1505dcd 100644
--- a/meson.build
+++ b/meson.build
@@ -13,6 +13,7 @@
   'util/matcher/rde_match_handler.cpp',
   'util/state_machine/discovery/base/base_disc_state_machine.cpp',
   'util/state_machine/discovery/rde/rde_disc_state_machine.cpp',
+  'util/state_machine/discovery/rde/dictionary.cpp',
 ]
 
 all_sources = ['rded.cpp'] + lib_sources
diff --git a/tests/discovery/rde/dictionary_test.cpp b/tests/discovery/rde/dictionary_test.cpp
new file mode 100644
index 0000000..824169d
--- /dev/null
+++ b/tests/discovery/rde/dictionary_test.cpp
@@ -0,0 +1,80 @@
+#include "util/state_machine/discovery/rde/dictionary.hpp"
+
+#include <stdplus/print.hpp>
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using ::testing::_;
+using ::testing::Return;
+
+class DictionaryTest : public ::testing::Test
+{
+  protected:
+    uint32_t resourceIdTest = 0x00000;
+    std::unique_ptr<Dictionary> dictionary =
+        std::make_unique<Dictionary>(resourceIdTest);
+};
+
+TEST_F(DictionaryTest, GetDictionaryBytesSuccess)
+{
+    std::vector<uint8_t> payloadPart1 = {0x01, 0x02, 0x03};
+    std::vector<uint8_t> payloadPart2 = {0x04, 0x05};
+    std::vector<uint8_t> payloadPart3 = {0x06, 0x07, 0x08, 0x09};
+
+    std::vector<uint8_t> expectedDictionary = {0x01, 0x02, 0x03, 0x04, 0x05,
+                                               0x06, 0x07, 0x08, 0x09};
+    OperationStatus status = dictionary->addToDictionaryBytes(
+        std::span<const uint8_t>(payloadPart1.data(), payloadPart1.size()),
+        false);
+    EXPECT_EQ(OperationStatus::Success, status);
+
+    status = dictionary->addToDictionaryBytes(
+        std::span<const uint8_t>(payloadPart2.data(), payloadPart2.size()),
+        false);
+    EXPECT_EQ(OperationStatus::Success, status);
+
+    dictionary->addToDictionaryBytes(
+        std::span<const uint8_t>(payloadPart3.data(), payloadPart3.size()),
+        false);
+    EXPECT_EQ(OperationStatus::Success, status);
+
+    std::span<const uint8_t> resultDictionary =
+        dictionary->getDictionaryBytes();
+    EXPECT_EQ(expectedDictionary, std::vector<uint8_t>(resultDictionary.begin(),
+                                                       resultDictionary.end()));
+}
+
+TEST_F(DictionaryTest, ChecksumFailure)
+{
+    std::vector<uint8_t> payloadPart1 = {0x01, 0x02, 0x03};
+    std::vector<uint8_t> payloadPart2 = {0x04, 0x05, 0x04, 0x05};
+
+    OperationStatus status = dictionary->addToDictionaryBytes(
+        std::span<const uint8_t>(payloadPart1.data(), payloadPart1.size()),
+        false);
+    EXPECT_EQ(OperationStatus::Success, status);
+
+    status = dictionary->addToDictionaryBytes(
+        std::span<const uint8_t>(payloadPart2.data(), payloadPart2.size()),
+        true);
+    EXPECT_EQ(OperationStatus::ChecksumFailure, status);
+}
+
+TEST_F(DictionaryTest, ChecksumSuccess)
+{
+    std::vector<uint8_t> payload = {0x01, 0x02, 0x03, 0x04, 0x05};
+    std::vector<uint8_t> payloadWithChecksum = {0xf4, 0x99, 0x0b, 0x47};
+
+    OperationStatus status = dictionary->addToDictionaryBytes(
+        std::span<const uint8_t>(payload.data(), payload.size()), false);
+    EXPECT_EQ(OperationStatus::Success, status);
+
+    status = dictionary->addToDictionaryBytes(
+        std::span<const uint8_t>(payloadWithChecksum.data(),
+                                 payloadWithChecksum.size()),
+        true);
+    EXPECT_EQ(OperationStatus::Success, status);
+}
diff --git a/tests/meson.build b/tests/meson.build
index 969f642..2686806 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -22,7 +22,8 @@
 tests = [
     'mctp_setup_test',
     'discovery/base/base_disc_state_machine_test',
-    'discovery/rde/rde_disc_state_machine_test'
+    'discovery/rde/rde_disc_state_machine_test',
+    'discovery/rde/dictionary_test',
 ]
 
 foreach t : tests
diff --git a/util/state_machine/discovery/rde/dictionary.cpp b/util/state_machine/discovery/rde/dictionary.cpp
new file mode 100644
index 0000000..809f4dc
--- /dev/null
+++ b/util/state_machine/discovery/rde/dictionary.cpp
@@ -0,0 +1,119 @@
+#include "dictionary.hpp"
+
+#include "libpldm/utils.h"
+
+#include <stdplus/print.hpp>
+
+Dictionary::Dictionary(uint32_t resourceId) : resourceId(resourceId)
+{}
+
+std::span<const uint8_t> Dictionary::getDictionaryBytes()
+{
+    return dictionary;
+}
+
+OperationStatus
+    Dictionary::addToDictionaryBytes(std::span<const uint8_t> payload,
+                                     bool hasChecksum)
+{
+    this->dictionary.insert(this->dictionary.end(), payload.begin(),
+                            payload.end());
+
+    if (hasChecksum)
+    {
+        OperationStatus checksumVerification = verifyChecksum();
+
+        // remove the checksum bytes from the dictionary
+        this->dictionary.erase(this->dictionary.begin() +
+                                   (this->dictionary.size() - 4),
+                               this->dictionary.end());
+
+        if (checksumVerification == OperationStatus::ChecksumFailure)
+        {
+            return checksumVerification;
+        }
+    }
+    return OperationStatus::Success;
+}
+
+OperationStatus Dictionary::verifyChecksum()
+{
+    uint32_t payloadLength = this->dictionary.size();
+    auto calculatedChecksum =
+        crc32(&(this->dictionary.front()), payloadLength - 4);
+    uint8_t byte0 = this->dictionary[payloadLength - 4];
+    uint8_t byte1 = this->dictionary[payloadLength - 3];
+    uint8_t byte2 = this->dictionary[payloadLength - 2];
+    uint8_t byte3 = this->dictionary[payloadLength - 1];
+
+    uint32_t receivedChecksum =
+        (byte0 | (byte1 << 8) | (byte2 << 16) | (byte3 << 24));
+
+    if (calculatedChecksum == receivedChecksum)
+    {
+        if (DEBUG)
+        {
+            stdplus::println(stderr,
+                             "Successfully verified checksum in "
+                             "dictionary extraction for resource id: {}"
+                             " with calculated checksum: {} and "
+                             "received checksum: {}",
+                             static_cast<uint32_t>(resourceId),
+                             static_cast<uint32_t>(calculatedChecksum),
+                             static_cast<uint32_t>(receivedChecksum));
+        }
+        return OperationStatus::Success;
+    }
+    stdplus::println(stderr,
+                     "Failed to verify checksum in "
+                     "dictionary extraction for resource id: {}"
+                     " with calculated checksum: {} and "
+                     "received checksum: {}",
+                     static_cast<uint32_t>(resourceId),
+                     static_cast<uint32_t>(calculatedChecksum),
+                     static_cast<uint32_t>(receivedChecksum));
+    return OperationStatus::ChecksumFailure;
+}
+
+// Getters and Setters
+
+uint32_t Dictionary::getResourceId() const
+{
+    return this->resourceId;
+}
+
+// Getter for currentSchemaClass
+uint8_t Dictionary::getCurrentSchemaClass() const
+{
+    return this->currentSchemaClass;
+}
+
+// Setter for currentSchemaClass
+void Dictionary::setCurrentSchemaClass(uint8_t newSchemaClass)
+{
+    this->currentSchemaClass = newSchemaClass;
+}
+
+// Getter for currentTransferHandle
+uint32_t Dictionary::getCurrentTransferHandle() const
+{
+    return this->currentTransferHandle;
+}
+
+// Setter for currentTransferHandle
+void Dictionary::setCurrentTransferHandle(uint32_t newTransferHandle)
+{
+    this->currentTransferHandle = newTransferHandle;
+}
+
+// Getter for currentTransferOperation
+uint8_t Dictionary::getCurrentTransferOperation() const
+{
+    return this->currentTransferOperation;
+}
+
+// Setter for currentTransferOperation
+void Dictionary::setCurrentTransferOperation(uint8_t newTransferOperation)
+{
+    this->currentTransferOperation = newTransferOperation;
+}
diff --git a/util/state_machine/discovery/rde/dictionary.hpp b/util/state_machine/discovery/rde/dictionary.hpp
new file mode 100644
index 0000000..13b248c
--- /dev/null
+++ b/util/state_machine/discovery/rde/dictionary.hpp
@@ -0,0 +1,51 @@
+#include "common.hpp"
+#include "state_machine_factory.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <vector>
+
+class Dictionary
+{
+  public:
+    Dictionary(uint32_t resourceId);
+
+    /**
+     * @brief Adds bytes to the end of the vector for the dictionary
+     *
+     * @param[in] payload - Bytes to be added
+     * @param[in] payloadLength - Size of the bytes to be added
+     * @param[in] hasChecksum - Contains checksum or not (last 4 bytes are
+     * checksum if it is true)
+     *
+     * @return OperationStatus
+     */
+    OperationStatus addToDictionaryBytes(std::span<const uint8_t> payload,
+                                         bool hasChecksum);
+
+    // Getters and Setters
+    uint32_t getResourceId() const;
+    std::span<const uint8_t> getDictionaryBytes();
+
+    uint8_t getCurrentSchemaClass() const;
+    void setCurrentSchemaClass(uint8_t newSchemaClass);
+
+    uint32_t getCurrentTransferHandle() const;
+    void setCurrentTransferHandle(uint32_t newTransferHandle);
+
+    uint8_t getCurrentTransferOperation() const;
+    void setCurrentTransferOperation(uint8_t newTransferOperation);
+
+  private:
+    uint32_t resourceId;
+    uint8_t currentSchemaClass;
+    uint32_t currentTransferHandle;
+    uint8_t currentTransferOperation;
+    std::vector<uint8_t> dictionary;
+
+    /**
+     * @brief Verifies checksum of the dictionary
+     */
+    OperationStatus verifyChecksum();
+};
diff --git a/util/state_machine/state_machine_factory.hpp b/util/state_machine/state_machine_factory.hpp
index d00a065..a6e5f77 100644
--- a/util/state_machine/state_machine_factory.hpp
+++ b/util/state_machine/state_machine_factory.hpp
@@ -33,6 +33,7 @@
     OperationFailure,
     StateMachineInitializationError,
     PartialFailure,
+    ChecksumFailure,
 };
 
 /**