diff --git a/src/ethernet_interface.cpp b/src/ethernet_interface.cpp
index b1ada82..9795a7e 100644
--- a/src/ethernet_interface.cpp
+++ b/src/ethernet_interface.cpp
@@ -324,7 +324,7 @@
         elog<InvalidArgument>(Argument::ARGUMENT_NAME("ipAddress"),
                               Argument::ARGUMENT_VALUE(ipAddress.c_str()));
     }
-    if (!mac_address::isUnicast(mac_address::fromString(macAddress)))
+    if (!mac_address::isUnicast(ToAddr<ether_addr>{}(macAddress)))
     {
         log<level::ERR>("Not a valid MAC address",
                         entry("MACADDRESS=%s", ipAddress.c_str()));
@@ -737,7 +737,7 @@
     std::optional<ether_addr> mac;
     if (!macStr.empty())
     {
-        mac.emplace(mac_address::fromString(macStr));
+        mac.emplace(ToAddr<ether_addr>{}(macStr));
     }
     auto info = system::InterfaceInfo{
         .idx = 0, // TODO: Query the correct value after creation
@@ -927,7 +927,7 @@
     ether_addr newMAC;
     try
     {
-        newMAC = mac_address::fromString(value);
+        newMAC = ToAddr<ether_addr>{}(value);
     }
     catch (const std::invalid_argument&)
     {
@@ -948,7 +948,7 @@
     auto validMAC = std::to_string(newMAC);
 
     // We don't need to update the system if the address is unchanged
-    ether_addr oldMAC = mac_address::fromString(MacAddressIntf::macAddress());
+    ether_addr oldMAC = ToAddr<ether_addr>{}(MacAddressIntf::macAddress());
     if (newMAC != oldMAC)
     {
         // Update everything that depends on the MAC value
diff --git a/src/types.hpp b/src/types.hpp
index 2bd895a..3c0b6d9 100644
--- a/src/types.hpp
+++ b/src/types.hpp
@@ -249,6 +249,43 @@
     }
 };
 
+template <typename T>
+struct ToAddr
+{
+};
+
+template <>
+struct ToAddr<ether_addr>
+{
+    constexpr ether_addr operator()(std::string_view str) const
+    {
+        constexpr DecodeInt<uint8_t, 16> di;
+        ether_addr ret;
+        if (str.size() == 12 && str.find(":") == str.npos)
+        {
+            for (size_t i = 0; i < 6; ++i)
+            {
+                ret.ether_addr_octet[i] = di(str.substr(i * 2, 2));
+            }
+        }
+        else
+        {
+            for (size_t i = 0; i < 5; ++i)
+            {
+                auto loc = str.find(":");
+                ret.ether_addr_octet[i] = di(str.substr(0, loc));
+                str.remove_prefix(loc == str.npos ? str.size() : loc + 1);
+                if (str.empty())
+                {
+                    throw std::invalid_argument("Missing mac data");
+                }
+            }
+            ret.ether_addr_octet[5] = di(str);
+        }
+        return ret;
+    }
+};
+
 namespace detail
 {
 
diff --git a/src/util.cpp b/src/util.cpp
index e65c17d..23ab4bf 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -415,45 +415,7 @@
 
     std::variant<std::string> value;
     reply.read(value);
-    return fromString(std::get<std::string>(value));
-}
-
-static uint8_t decodeHex(std::string_view str)
-{
-    uint8_t ret;
-    auto res = std::from_chars(str.begin(), str.end(), ret, 16);
-    if (res.ptr != str.end() || res.ec != std::errc())
-    {
-        throw std::invalid_argument("Not hex");
-    }
-    return ret;
-}
-
-ether_addr fromString(std::string_view str)
-{
-    ether_addr ret;
-    if (str.size() == 12 && str.find(":") == str.npos)
-    {
-        for (size_t i = 0; i < 6; ++i)
-        {
-            ret.ether_addr_octet[i] = decodeHex(str.substr(i * 2, 2));
-        }
-    }
-    else
-    {
-        for (size_t i = 0; i < 5; ++i)
-        {
-            auto loc = str.find(":");
-            ret.ether_addr_octet[i] = decodeHex(str.substr(0, loc));
-            str.remove_prefix(loc == str.npos ? str.size() : loc + 1);
-            if (str.empty())
-            {
-                throw std::invalid_argument("Missing mac data");
-            }
-        }
-        ret.ether_addr_octet[5] = decodeHex(str);
-    }
-    return ret;
+    return ToAddr<ether_addr>{}(std::get<std::string>(value));
 }
 
 bool isEmpty(const ether_addr& mac)
diff --git a/src/util.hpp b/src/util.hpp
index 19eb108..ea9d767 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -36,13 +36,6 @@
  */
 ether_addr getfromInventory(sdbusplus::bus_t& bus, const std::string& intfName);
 
-/** @brief Converts the given mac address into byte form
- *  @param[in] str - The mac address in human readable form
- *  @returns A mac address in network byte order
- *  @throws std::runtime_error for bad mac
- */
-ether_addr fromString(std::string_view str);
-
 /** @brief Determines if the mac address is empty
  *  @param[in] mac - The mac address
  *  @return True if 00:00:00:00:00:00
diff --git a/test/test_types.cpp b/test/test_types.cpp
index 46e8291..f9e49b3 100644
--- a/test/test_types.cpp
+++ b/test/test_types.cpp
@@ -87,6 +87,39 @@
     EXPECT_NE(InAddrAny(in6_addr{1}), InAddrAny(in6_addr{}));
 }
 
+TEST(ToAddr, EtherAddr)
+{
+    EXPECT_THROW(ToAddr<ether_addr>{}("0x:00:00:00:00:00"),
+                 std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}("00:00:00:00:00"), std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}("00:00:00:00:00:"),
+                 std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}("00:00:00:00::00"),
+                 std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}(":00:00:00:00:00"),
+                 std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}("00::00:00:00:00"),
+                 std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}(":::::"), std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}("00:0:0:0:0"), std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}("00:00:00:00:00:00:00"),
+                 std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}(""), std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}("123456789XYZ"), std::invalid_argument);
+    EXPECT_THROW(ToAddr<ether_addr>{}("123456789AB"), std::overflow_error);
+    EXPECT_THROW(ToAddr<ether_addr>{}("123456789ABCD"), std::overflow_error);
+
+    EXPECT_EQ((ether_addr{}), ToAddr<ether_addr>{}("00:00:00:00:00:00"));
+    EXPECT_EQ((ether_addr{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa}),
+              ToAddr<ether_addr>{}("FF:EE:DD:cc:bb:aa"));
+    EXPECT_EQ((ether_addr{0x00, 0x01, 0x02, 0x03, 0x04, 0x05}),
+              ToAddr<ether_addr>{}("0:1:2:3:4:5"));
+    EXPECT_EQ((ether_addr{0x01, 0x23, 0x45, 0x67, 0x89, 0xab}),
+              ToAddr<ether_addr>{}("0123456789AB"));
+    EXPECT_EQ((ether_addr{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa}),
+              ToAddr<ether_addr>{}("FFEEDDccbbaa"));
+}
+
 namespace detail
 {
 
diff --git a/test/test_util.cpp b/test/test_util.cpp
index 39f5c39..b0474ea 100644
--- a/test/test_util.cpp
+++ b/test/test_util.cpp
@@ -121,36 +121,6 @@
 namespace mac_address
 {
 
-TEST(MacFromString, Bad)
-{
-    EXPECT_THROW(fromString("0x:00:00:00:00:00"), std::invalid_argument);
-    EXPECT_THROW(fromString("00:00:00:00:00"), std::invalid_argument);
-    EXPECT_THROW(fromString("00:00:00:00:00:"), std::invalid_argument);
-    EXPECT_THROW(fromString("00:00:00:00::00"), std::invalid_argument);
-    EXPECT_THROW(fromString(":00:00:00:00:00"), std::invalid_argument);
-    EXPECT_THROW(fromString("00::00:00:00:00"), std::invalid_argument);
-    EXPECT_THROW(fromString(":::::"), std::invalid_argument);
-    EXPECT_THROW(fromString("00:0:0:0:0"), std::invalid_argument);
-    EXPECT_THROW(fromString("00:00:00:00:00:00:00"), std::invalid_argument);
-    EXPECT_THROW(fromString(""), std::invalid_argument);
-    EXPECT_THROW(fromString("123456789XYZ"), std::invalid_argument);
-    EXPECT_THROW(fromString("123456789AB"), std::invalid_argument);
-    EXPECT_THROW(fromString("123456789ABCD"), std::invalid_argument);
-}
-
-TEST(MacFromString, Valid)
-{
-    EXPECT_EQ((ether_addr{}), fromString("00:00:00:00:00:00"));
-    EXPECT_EQ((ether_addr{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa}),
-              fromString("FF:EE:DD:cc:bb:aa"));
-    EXPECT_EQ((ether_addr{0x00, 0x01, 0x02, 0x03, 0x04, 0x05}),
-              fromString("0:1:2:3:4:5"));
-    EXPECT_EQ((ether_addr{0x01, 0x23, 0x45, 0x67, 0x89, 0xab}),
-              fromString("0123456789AB"));
-    EXPECT_EQ((ether_addr{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa}),
-              fromString("FFEEDDccbbaa"));
-}
-
 TEST(MacIsEmpty, True)
 {
     EXPECT_TRUE(isEmpty({}));
@@ -158,34 +128,34 @@
 
 TEST(MacIsEmpty, False)
 {
-    EXPECT_FALSE(isEmpty(fromString("01:00:00:00:00:00")));
-    EXPECT_FALSE(isEmpty(fromString("00:00:00:10:00:00")));
-    EXPECT_FALSE(isEmpty(fromString("00:00:00:00:00:01")));
+    EXPECT_FALSE(isEmpty({1}));
+    EXPECT_FALSE(isEmpty({0, 0, 0, 1}));
+    EXPECT_FALSE(isEmpty({0, 0, 0, 0, 0, 1}));
 }
 
 TEST(MacIsMulticast, True)
 {
-    EXPECT_TRUE(isMulticast(fromString("ff:ff:ff:ff:ff:ff")));
-    EXPECT_TRUE(isMulticast(fromString("01:00:00:00:00:00")));
+    EXPECT_TRUE(isMulticast({255, 255, 255, 255, 255, 255}));
+    EXPECT_TRUE(isMulticast({1}));
 }
 
 TEST(MacIsMulticast, False)
 {
-    EXPECT_FALSE(isMulticast(fromString("00:11:22:33:44:55")));
-    EXPECT_FALSE(isMulticast(fromString("FE:11:22:33:44:55")));
+    EXPECT_FALSE(isMulticast({0, 1, 2, 3, 4, 5}));
+    EXPECT_FALSE(isMulticast({0xfe, 255, 255, 255, 255, 255}));
 }
 
 TEST(MacIsUnicast, True)
 {
-    EXPECT_TRUE(isUnicast(fromString("00:11:22:33:44:55")));
-    EXPECT_TRUE(isUnicast(fromString("FE:11:22:33:44:55")));
+    EXPECT_TRUE(isUnicast({0, 1, 2, 3, 4, 5}));
+    EXPECT_TRUE(isUnicast({0xfe, 255, 255, 255, 255, 255}));
 }
 
 TEST(MacIsUnicast, False)
 {
-    EXPECT_FALSE(isUnicast(fromString("00:00:00:00:00:00")));
-    EXPECT_FALSE(isUnicast(fromString("01:00:00:00:00:00")));
-    EXPECT_FALSE(isUnicast(fromString("ff:ff:ff:ff:ff:ff")));
+    EXPECT_FALSE(isUnicast({}));
+    EXPECT_FALSE(isUnicast({1}));
+    EXPECT_FALSE(isUnicast({255, 255, 255, 255, 255, 255}));
 }
 
 TEST(IgnoredInterfaces, Empty)