diff --git a/include/xrpl/basics/Mutex.hpp b/include/xrpl/basics/Mutex.hpp
new file mode 100644
index 0000000000..18c57370b1
--- /dev/null
+++ b/include/xrpl/basics/Mutex.hpp
@@ -0,0 +1,155 @@
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2024, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+*/
+
+#pragma once
+
+#include <mutex>
+#include <type_traits>
+
+namespace xrpl {
+
+template <typename ProtectedDataType, typename MutexType>
+class Mutex;
+
+/**
+ * @brief A lock on a mutex that provides access to the protected data.
+ *
+ * @tparam ProtectedDataType data type to hold
+ * @tparam LockType type of lock
+ * @tparam MutexType type of mutex
+ */
+template <typename ProtectedDataType, template <typename...> typename LockType, typename MutexType>
+class Lock
+{
+    LockType<MutexType> lock_;
+    ProtectedDataType& data_;
+
+public:
+    /** @cond */
+    ProtectedDataType const&
+    operator*() const
+    {
+        return data_;
+    }
+
+    ProtectedDataType&
+    operator*()
+    {
+        return data_;
+    }
+
+    ProtectedDataType const&
+    get() const
+    {
+        return data_;
+    }
+
+    ProtectedDataType&
+    get()
+    {
+        return data_;
+    }
+
+    ProtectedDataType const*
+    operator->() const
+    {
+        return &data_;
+    }
+
+    ProtectedDataType*
+    operator->()
+    {
+        return &data_;
+    }
+
+    operator LockType<MutexType>&() &
+    {
+        return lock_;
+    }
+
+    operator LockType<MutexType> const&() const&
+    {
+        return lock_;
+    }
+    /** @endcond */
+
+private:
+    friend class Mutex<std::remove_const_t<ProtectedDataType>, MutexType>;
+
+    Lock(MutexType& mutex, ProtectedDataType& data) : lock_(mutex), data_(data)
+    {
+    }
+};
+
+/**
+ * @brief A container for data that is protected by a mutex. Inspired by Mutex in Rust.
+ *
+ * @tparam ProtectedDataType data type to hold
+ * @tparam MutexType type of mutex
+ */
+template <typename ProtectedDataType, typename MutexType = std::mutex>
+class Mutex
+{
+    mutable MutexType mutex_;
+    ProtectedDataType data_{};
+
+public:
+    Mutex() = default;
+
+    /**
+     * @brief Construct a new Mutex object with the given data
+     *
+     * @param data The data to protect
+     */
+    explicit Mutex(ProtectedDataType data) : data_(std::move(data))
+    {
+    }
+
+    /**
+     * @brief Make a new Mutex object with the given data
+     *
+     * @tparam Args The types of the arguments to forward to the constructor of the protected data
+     * @param args The arguments to forward to the constructor of the protected data
+     * @return The Mutex object that protects the given data
+     */
+    template <typename... Args>
+    static Mutex
+    make(Args&&... args)
+    {
+        return Mutex{ProtectedDataType{std::forward<Args>(args)...}};
+    }
+
+    /**
+     * @brief Lock the mutex and get a lock object allowing access to the protected data
+     *
+     * @tparam LockType The type of lock to use
+     * @return A lock on the mutex and a reference to the protected data
+     */
+    template <template <typename...> typename LockType = std::lock_guard>
+    Lock<ProtectedDataType const, LockType, MutexType>
+    lock() const
+    {
+        return {mutex_, data_};
+    }
+
+    /**
+     * @brief Lock the mutex and get a lock object allowing access to the protected data
+     *
+     * @tparam LockType The type of lock to use
+     * @return A lock on the mutex and a reference to the protected data
+     */
+    template <template <typename...> typename LockType = std::lock_guard>
+    Lock<ProtectedDataType, LockType, MutexType>
+    lock()
+    {
+        return {mutex_, data_};
+    }
+};
+
+}  // namespace xrpl
diff --git a/src/tests/libxrpl/basics/Mutex.cpp b/src/tests/libxrpl/basics/Mutex.cpp
new file mode 100644
index 0000000000..3bcee92276
--- /dev/null
+++ b/src/tests/libxrpl/basics/Mutex.cpp
@@ -0,0 +1,288 @@
+#include <xrpl/basics/Mutex.hpp>
+
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <string>
+#include <vector>
+
+using namespace xrpl;
+
+struct MutexMakeTest : ::testing::Test
+{
+};
+
+TEST_F(MutexMakeTest, default_constructor)
+{
+    auto m = Mutex<int>::make();
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 0);
+}
+
+TEST_F(MutexMakeTest, single_argument)
+{
+    auto m = Mutex<int>::make(42);
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 42);
+}
+
+TEST_F(MutexMakeTest, string_argument)
+{
+    auto m = Mutex<std::string>::make("test");
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, "test");
+}
+
+TEST_F(MutexMakeTest, move_only_type)
+{
+    auto m = Mutex<std::unique_ptr<int>>::make(std::make_unique<int>(100));
+    auto lock = m.lock();
+    EXPECT_NE(lock->get(), nullptr);
+    EXPECT_EQ(**lock, 100);
+}
+
+struct MutexDirectConstructionTest : ::testing::Test
+{
+};
+
+TEST_F(MutexDirectConstructionTest, default_constructor)
+{
+    // Test default construction with a type that has a non-trivial
+    // default constructor
+    Mutex<std::string> m;
+    auto lock = m.lock();
+    EXPECT_TRUE(lock->empty());
+}
+
+TEST_F(MutexDirectConstructionTest, default_initialization)
+{
+    Mutex<int> m;
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 0);
+}
+
+TEST_F(MutexDirectConstructionTest, constructor_with_value)
+{
+    Mutex<int> m(42);
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 42);
+}
+
+TEST_F(MutexDirectConstructionTest, constructor_with_string)
+{
+    Mutex<std::string> m(std::string("hello"));
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, "hello");
+}
+
+struct MutexLockNonConstTest : ::testing::Test
+{
+};
+
+TEST_F(MutexLockNonConstTest, operator_star)
+{
+    Mutex<int> m(10);
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(*lock, 10);
+        *lock = 20;
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 20);
+}
+
+TEST_F(MutexLockNonConstTest, get_method)
+{
+    Mutex<int> m(10);
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock.get(), 10);
+        lock.get() = 30;
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(lock.get(), 30);
+}
+
+TEST_F(MutexLockNonConstTest, operator_arrow)
+{
+    Mutex<std::string> m(std::string("test"));
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock->size(), 4);
+        lock->append(" string");
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, "test string");
+}
+
+TEST_F(MutexLockNonConstTest, multiple_modifications)
+{
+    Mutex<int> m(10);
+    {
+        auto lock = m.lock();
+        *lock = 20;
+    }
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock.get(), 20);
+        lock.get() = 30;
+    }
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(*lock, 30);
+    }
+}
+
+struct MutexLockConstTest : ::testing::Test
+{
+};
+
+TEST_F(MutexLockConstTest, operator_star)
+{
+    Mutex<int> const m(42);
+    auto lock = m.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
+    EXPECT_EQ(*lock, 42);
+}
+
+TEST_F(MutexLockConstTest, get_method)
+{
+    Mutex<int> const m(42);
+    auto lock = m.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(lock.get())>>);
+    EXPECT_EQ(lock.get(), 42);
+}
+
+TEST_F(MutexLockConstTest, operator_arrow)
+{
+    Mutex<std::string> const m(std::string("test"));
+    auto lock = m.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
+    EXPECT_EQ(lock->size(), 4);
+    EXPECT_EQ(lock->at(0), 't');
+}
+
+struct MutexConstCorrectnessTest : ::testing::Test
+{
+};
+
+TEST_F(MutexConstCorrectnessTest, non_const_allows_modification)
+{
+    Mutex<std::vector<int>> m({1, 2, 3, 4, 5});
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock->size(), 5);
+        lock->push_back(6);
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(lock->size(), 6);
+    EXPECT_EQ(lock->back(), 6);
+}
+
+TEST_F(MutexConstCorrectnessTest, const_reference_provides_const_access)
+{
+    Mutex<std::vector<int>> m({1, 2, 3, 4, 5, 6});
+    Mutex<std::vector<int>> const& const_ref = m;
+    auto lock = const_ref.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
+    EXPECT_EQ(lock->size(), 6);
+    EXPECT_EQ(lock->at(5), 6);
+}
+
+struct MutexDifferentLockTypesTest : ::testing::Test
+{
+};
+
+TEST_F(MutexDifferentLockTypesTest, lock_guard)
+{
+    Mutex<int> m(0);
+    {
+        auto lock = m.lock();
+        *lock = 1;
+    }
+    auto lock = m.lock();
+    EXPECT_EQ(*lock, 1);
+}
+
+TEST_F(MutexDifferentLockTypesTest, unique_lock)
+{
+    Mutex<int> m(0);
+    auto lock = m.lock<std::unique_lock>();
+    EXPECT_EQ(*lock, 0);
+    *lock = 2;
+
+    std::unique_lock<std::mutex>& ul = lock;
+    ul.unlock();
+    ul.lock();
+    EXPECT_EQ(*lock, 2);
+}
+
+struct MutexSharedMutexTest : ::testing::Test
+{
+};
+
+TEST_F(MutexSharedMutexTest, shared_lock_for_const_access)
+{
+    Mutex<int, std::shared_mutex> m(100);
+    Mutex<int, std::shared_mutex> const& const_ref = m;
+    auto lock = const_ref.lock<std::shared_lock>();
+    EXPECT_EQ(*lock, 100);
+}
+
+TEST_F(MutexSharedMutexTest, unique_lock_for_mutable_access)
+{
+    Mutex<int, std::shared_mutex> m(100);
+    {
+        auto lock = m.lock<std::unique_lock>();
+        *lock = 200;
+    }
+    auto lock = m.lock<std::shared_lock>();
+    EXPECT_EQ(*lock, 200);
+}
+
+struct MutexComplexTypeTest : ::testing::Test
+{
+    struct Data
+    {
+        int x;
+        std::string y;
+
+        Data(int x_, std::string y_) : x(x_), y(std::move(y_))
+        {
+        }
+    };
+};
+
+TEST_F(MutexComplexTypeTest, construct_and_access)
+{
+    auto m = Mutex<Data>::make(42, "hello");
+    auto lock = m.lock();
+    EXPECT_EQ(lock->x, 42);
+    EXPECT_EQ(lock->y, "hello");
+}
+
+TEST_F(MutexComplexTypeTest, modify_fields)
+{
+    auto m = Mutex<Data>::make(42, "hello");
+    {
+        auto lock = m.lock();
+        lock->x = 100;
+        lock->y = "world";
+    }
+    {
+        auto lock = m.lock();
+        EXPECT_EQ(lock->x, 100);
+        EXPECT_EQ(lock->y, "world");
+    }
+}
+
+TEST_F(MutexComplexTypeTest, const_access_to_fields)
+{
+    auto const m = Mutex<Data>::make(42, "hello");
+    auto lock = m.lock();
+    static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
+    EXPECT_EQ(lock->x, 42);
+    EXPECT_EQ(lock->y, "hello");
+}