diff --git a/README.md b/README.md
index 7c62c339705..d622f5b1e03 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ This class is aligned with the JSON standard, [RFC
 ## Library usage
 
 This is a fork of univalue used by Bitcoin Core. It is not maintained for usage
-by other projects. Notably, the API may break in non-backward-compatible ways.
+by other projects. Notably, the API is broken in non-backward-compatible ways.
 
 Other projects looking for a maintained library should use the upstream
 univalue at https://github.com/jgarzik/univalue.
diff --git a/configure.ac b/configure.ac
index 495b25a53d8..ed9c5f0c5ca 100644
--- a/configure.ac
+++ b/configure.ac
@@ -45,8 +45,8 @@ AC_SUBST(LIBUNIVALUE_AGE)
 LT_INIT
 LT_LANG([C++])
 
-dnl Require C++11 compiler (no GNU extensions)
-AX_CXX_COMPILE_STDCXX([11], [noext], [mandatory], [nodefault])
+dnl Require C++17 compiler (no GNU extensions)
+AX_CXX_COMPILE_STDCXX([17], [noext], [mandatory], [nodefault])
 
 case $host in
   *mingw*)
diff --git a/gen/gen.cpp b/gen/gen.cpp
index b8a6c73f4ec..ca5b470ddcb 100644
--- a/gen/gen.cpp
+++ b/gen/gen.cpp
@@ -8,9 +8,11 @@
 // $ ./gen > univalue_escapes.h
 //
 
-#include <stdio.h>
-#include <string.h>
-#include "univalue.h"
+#include <univalue.h>
+
+#include <cstdio>
+#include <cstring>
+#include <string>
 
 static bool initEscapes;
 static std::string escapes[256];
diff --git a/include/univalue.h b/include/univalue.h
index fc5cf402be3..35eaa2dd0d6 100644
--- a/include/univalue.h
+++ b/include/univalue.h
@@ -6,13 +6,14 @@
 #ifndef __UNIVALUE_H__
 #define __UNIVALUE_H__
 
-#include <stdint.h>
-#include <string.h>
-
-#include <string>
-#include <vector>
+#include <charconv>
+#include <cstdint>
+#include <cstring>
 #include <map>
-#include <cassert>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
 
 class UniValue {
 public:
@@ -168,10 +169,24 @@ public:
     // value is of unexpected type
     const std::vector<std::string>& getKeys() const;
     const std::vector<UniValue>& getValues() const;
+    template <typename Int>
+    auto getInt() const
+    {
+        static_assert(std::is_integral<Int>::value);
+        if (typ != VNUM) {
+            throw std::runtime_error("JSON value is not an integer as expected");
+        }
+        Int result;
+        const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
+        if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
+            throw std::runtime_error("JSON integer out of range");
+        }
+        return result;
+    }
     bool get_bool() const;
     const std::string& get_str() const;
-    int get_int() const;
-    int64_t get_int64() const;
+    auto get_int() const { return getInt<int>(); };
+    auto get_int64() const { return getInt<int64_t>(); };
     double get_real() const;
     const UniValue& get_obj() const;
     const UniValue& get_array() const;
diff --git a/lib/univalue.cpp b/lib/univalue.cpp
index c4e59fae744..3553995c28f 100644
--- a/lib/univalue.cpp
+++ b/lib/univalue.cpp
@@ -3,12 +3,15 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://opensource.org/licenses/mit-license.php.
 
-#include <stdint.h>
-#include <iomanip>
-#include <sstream>
-#include <stdlib.h>
+#include <univalue.h>
 
-#include "univalue.h"
+#include <iomanip>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
 
 const UniValue NullUniValue;
 
diff --git a/lib/univalue_get.cpp b/lib/univalue_get.cpp
index 5af89a3561c..9bbdb1fe69b 100644
--- a/lib/univalue_get.cpp
+++ b/lib/univalue_get.cpp
@@ -3,17 +3,18 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://opensource.org/licenses/mit-license.php.
 
-#include <stdint.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdexcept>
-#include <vector>
-#include <limits>
-#include <string>
-#include <sstream>
+#include <univalue.h>
 
-#include "univalue.h"
+#include <cerrno>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <locale>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
 
 namespace
 {
@@ -28,37 +29,6 @@ static bool ParsePrechecks(const std::string& str)
     return true;
 }
 
-bool ParseInt32(const std::string& str, int32_t *out)
-{
-    if (!ParsePrechecks(str))
-        return false;
-    char *endp = nullptr;
-    errno = 0; // strtol will not set errno if valid
-    long int n = strtol(str.c_str(), &endp, 10);
-    if(out) *out = (int32_t)n;
-    // Note that strtol returns a *long int*, so even if strtol doesn't report an over/underflow
-    // we still have to check that the returned value is within the range of an *int32_t*. On 64-bit
-    // platforms the size of these types may be different.
-    return endp && *endp == 0 && !errno &&
-        n >= std::numeric_limits<int32_t>::min() &&
-        n <= std::numeric_limits<int32_t>::max();
-}
-
-bool ParseInt64(const std::string& str, int64_t *out)
-{
-    if (!ParsePrechecks(str))
-        return false;
-    char *endp = nullptr;
-    errno = 0; // strtoll will not set errno if valid
-    long long int n = strtoll(str.c_str(), &endp, 10);
-    if(out) *out = (int64_t)n;
-    // Note that strtoll returns a *long long int*, so even if strtol doesn't report a over/underflow
-    // we still have to check that the returned value is within the range of an *int64_t*.
-    return endp && *endp == 0 && !errno &&
-        n >= std::numeric_limits<int64_t>::min() &&
-        n <= std::numeric_limits<int64_t>::max();
-}
-
 bool ParseDouble(const std::string& str, double *out)
 {
     if (!ParsePrechecks(str))
@@ -102,26 +72,6 @@ const std::string& UniValue::get_str() const
     return getValStr();
 }
 
-int UniValue::get_int() const
-{
-    if (typ != VNUM)
-        throw std::runtime_error("JSON value is not an integer as expected");
-    int32_t retval;
-    if (!ParseInt32(getValStr(), &retval))
-        throw std::runtime_error("JSON integer out of range");
-    return retval;
-}
-
-int64_t UniValue::get_int64() const
-{
-    if (typ != VNUM)
-        throw std::runtime_error("JSON value is not an integer as expected");
-    int64_t retval;
-    if (!ParseInt64(getValStr(), &retval))
-        throw std::runtime_error("JSON integer out of range");
-    return retval;
-}
-
 double UniValue::get_real() const
 {
     if (typ != VNUM)
diff --git a/lib/univalue_read.cpp b/lib/univalue_read.cpp
index be39bfe57a7..a6ed75e57a7 100644
--- a/lib/univalue_read.cpp
+++ b/lib/univalue_read.cpp
@@ -2,19 +2,22 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://opensource.org/licenses/mit-license.php.
 
-#include <string.h>
-#include <vector>
-#include <stdio.h>
-#include "univalue.h"
+#include <univalue.h>
 #include "univalue_utffilter.h"
 
+#include <cstdio>
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <vector>
+
 /*
  * According to stackexchange, the original json test suite wanted
  * to limit depth to 22.  Widely-deployed PHP bails at depth 512,
  * so we will follow PHP's lead, which should be more than sufficient
  * (further stackexchange comments indicate depth > 32 rarely occurs).
  */
-static const size_t MAX_JSON_DEPTH = 512;
+static constexpr size_t MAX_JSON_DEPTH = 512;
 
 static bool json_isdigit(int ch)
 {
diff --git a/lib/univalue_write.cpp b/lib/univalue_write.cpp
index 3a2c580c7f6..18833077b77 100644
--- a/lib/univalue_write.cpp
+++ b/lib/univalue_write.cpp
@@ -2,11 +2,13 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://opensource.org/licenses/mit-license.php.
 
-#include <iomanip>
-#include <stdio.h>
-#include "univalue.h"
+#include <univalue.h>
 #include "univalue_escapes.h"
 
+#include <memory>
+#include <string>
+#include <vector>
+
 static std::string json_escape(const std::string& inS)
 {
     std::string outS;
diff --git a/test/no_nul.cpp b/test/no_nul.cpp
index 83d292200bf..3a7a727abbd 100644
--- a/test/no_nul.cpp
+++ b/test/no_nul.cpp
@@ -1,4 +1,4 @@
-#include "univalue.h"
+#include <univalue.h>
 
 int main (int argc, char *argv[])
 {
diff --git a/test/object.cpp b/test/object.cpp
index c2f52f83ac2..b9697a8cb7a 100644
--- a/test/object.cpp
+++ b/test/object.cpp
@@ -3,14 +3,16 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://opensource.org/licenses/mit-license.php.
 
-#include <stdint.h>
-#include <vector>
-#include <string>
-#include <map>
-#include <cassert>
-#include <stdexcept>
 #include <univalue.h>
 
+#include <cassert>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
 #define BOOST_FIXTURE_TEST_SUITE(a, b)
 #define BOOST_AUTO_TEST_CASE(funcName) void funcName()
 #define BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/test_json.cpp b/test/test_json.cpp
index 2943bae2b15..f8c10238d4d 100644
--- a/test/test_json.cpp
+++ b/test/test_json.cpp
@@ -4,9 +4,11 @@
 // It reads JSON input from stdin and exits with code 0 if it can be parsed
 // successfully. It also pretty prints the parsed JSON value to stdout.
 
+#include <univalue.h>
+
 #include <iostream>
+#include <iterator>
 #include <string>
-#include "univalue.h"
 
 using namespace std;
 
diff --git a/test/unitester.cpp b/test/unitester.cpp
index 02e1a83c6df..81b1c5d3b1a 100644
--- a/test/unitester.cpp
+++ b/test/unitester.cpp
@@ -2,12 +2,11 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or https://opensource.org/licenses/mit-license.php.
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
+#include <univalue.h>
+
 #include <cassert>
+#include <cstdio>
 #include <string>
-#include "univalue.h"
 
 #ifndef JSON_TEST_SRC
 #error JSON_TEST_SRC must point to test source directory