diff --git a/src/config/CMakeLists.txt b/src/config/CMakeLists.txt
--- a/src/config/CMakeLists.txt
+++ b/src/config/CMakeLists.txt
@@ -56,14 +56,14 @@
 check_include_files("sys/prctl.h" HAVE_SYS_PRCTL_H)
 
 # Bitmanip intrinsics
-function(check_builtin_exist SYMBOL VARIABLE)
+function(check_builtin_exist SYMBOL VARIABLE ARGS)
 	set(
 		SOURCE_FILE
 		"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckBuiltinExists.c"
 	)
 	set(
 		CMAKE_CONFIGURABLE_FILE_CONTENT
-		"int main(int argc, char** argv) { (void)argv; return ${SYMBOL}(argc); }\n"
+		"int main(int argc, char** argv) { (void)argv; return ${SYMBOL}(${ARGS}); }\n"
 	)
 	configure_file(
 		"${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
@@ -101,10 +101,16 @@
 	endif()
 endfunction()
 
-check_builtin_exist(__builtin_clz HAVE_DECL___BUILTIN_CLZ)
-check_builtin_exist(__builtin_clzl HAVE_DECL___BUILTIN_CLZL)
-check_builtin_exist(__builtin_clzll HAVE_DECL___BUILTIN_CLZLL)
-check_builtin_exist(__builtin_popcount HAVE_DECL___BUILTIN_POPCOUNT)
+check_builtin_exist(__builtin_clz HAVE_DECL___BUILTIN_CLZ "argc")
+check_builtin_exist(__builtin_clzl HAVE_DECL___BUILTIN_CLZL "argc")
+check_builtin_exist(__builtin_clzll HAVE_DECL___BUILTIN_CLZLL "argc")
+check_builtin_exist(__builtin_popcount HAVE_DECL___BUILTIN_POPCOUNT "argc")
+check_builtin_exist(
+	__builtin_saddll_overflow HAVE_DECL___BUILTIN_SADDLL_OVERFLOW
+	"argc, argc, (long long int*)&argc")
+check_builtin_exist(
+	__builtin_ssubll_overflow HAVE_DECL___BUILTIN_SSUBLL_OVERFLOW
+	"argc, argc, (long long int*)&argc")
 
 # Memory management capabilities
 check_symbol_exists(M_ARENA_MAX "malloc.h" HAVE_MALLOPT_ARENA_MAX)
diff --git a/src/config/bitcoin-config.h.cmake.in b/src/config/bitcoin-config.h.cmake.in
--- a/src/config/bitcoin-config.h.cmake.in
+++ b/src/config/bitcoin-config.h.cmake.in
@@ -41,6 +41,8 @@
 #cmakedefine HAVE_DECL___BUILTIN_CLZL 1
 #cmakedefine HAVE_DECL___BUILTIN_CLZLL 1
 #cmakedefine HAVE_DECL___BUILTIN_POPCOUNT 1
+#cmakedefine HAVE_DECL___BUILTIN_SADDLL_OVERFLOW 1
+#cmakedefine HAVE_DECL___BUILTIN_SSUBLL_OVERFLOW 1
 
 #cmakedefine HAVE_MALLOPT_ARENA_MAX 1
 #cmakedefine HAVE_MALLOC_INFO 1
diff --git a/src/script/script.h b/src/script/script.h
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -271,10 +271,18 @@
     }
 
     inline CScriptNum operator+(const int64_t &rhs) const {
-        return CScriptNum(m_value + rhs);
+        int64_t result;
+        if (overflow_add_int64(m_value, rhs, result)) {
+            throw scriptnum_error("script number add overflow");
+        }
+        return CScriptNum(result);
     }
     inline CScriptNum operator-(const int64_t &rhs) const {
-        return CScriptNum(m_value - rhs);
+        int64_t result;
+        if (overflow_sub_int64(m_value, rhs, result)) {
+            throw scriptnum_error("script number sub overflow");
+        }
+        return CScriptNum(result);
     }
     inline CScriptNum operator+(const CScriptNum &rhs) const {
         return operator+(rhs.m_value);
@@ -284,6 +292,10 @@
     }
 
     inline CScriptNum operator/(const int64_t &rhs) const {
+        // Sanity check for invalid script num; should never occur
+        assert(m_value != std::numeric_limits<int64_t>::min());
+        // Sanity check for division by 0; should be handled before
+        assert(rhs != 0);
         return CScriptNum(m_value / rhs);
     }
     inline CScriptNum operator/(const CScriptNum &rhs) const {
@@ -291,6 +303,10 @@
     }
 
     inline CScriptNum operator%(const int64_t &rhs) const {
+        // Sanity check for invalid script num; should never occur
+        assert(m_value != std::numeric_limits<int64_t>::min());
+        // Sanity check for division by 0; should be handled before
+        assert(rhs != 0);
         return CScriptNum(m_value % rhs);
     }
     inline CScriptNum operator%(const CScriptNum &rhs) const {
@@ -316,6 +332,7 @@
     }
 
     inline CScriptNum operator-() const {
+        // Sanity check for invalid script num; should never occur
         assert(m_value != std::numeric_limits<int64_t>::min());
         return CScriptNum(-m_value);
     }
@@ -326,20 +343,20 @@
     }
 
     inline CScriptNum &operator+=(const int64_t &rhs) {
-        assert(
-            rhs == 0 ||
-            (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
-            (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
-        m_value += rhs;
+        int64_t result;
+        if (overflow_add_int64(m_value, rhs, result)) {
+            throw scriptnum_error("script number add overflow");
+        }
+        m_value = result;
         return *this;
     }
 
     inline CScriptNum &operator-=(const int64_t &rhs) {
-        assert(
-            rhs == 0 ||
-            (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
-            (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
-        m_value -= rhs;
+        int64_t result;
+        if (overflow_sub_int64(m_value, rhs, result)) {
+            throw scriptnum_error("script number sub overflow");
+        }
+        m_value = result;
         return *this;
     }
 
@@ -411,6 +428,66 @@
         return result;
     }
 
+    /**
+     * Computes a + b and stores it in result. If the sum overflows or results
+     * in an invalid Script integer, return true, otherwise false.
+     */
+    static bool overflow_add_int64(int64_t a, int64_t b, int64_t &result) {
+#if HAVE_DECL___BUILTIN_SADDLL_OVERFLOW
+        static_assert(std::numeric_limits<long long int>::max() ==
+                      std::numeric_limits<int64_t>::max());
+        long long int tmp_result; // must use long long int due to types
+        if (__builtin_saddll_overflow(a, b, &tmp_result)) {
+            return true;
+        }
+        result = tmp_result;
+#else
+        if (a > 0 && b > std::numeric_limits<int64_t>::max() - a) {
+            // integer overflow
+            return true;
+        }
+        if (a < 0 && b <= std::numeric_limits<int64_t>::min() - a) {
+            // integer underflow
+            return true;
+        }
+        result = a + b;
+#endif
+        if (result == std::numeric_limits<int64_t>::min()) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Computes a - b and stores it in result. If the difference overflows or
+     * results in an invalid Script integer, return true, otherwise false.
+     */
+    static bool overflow_sub_int64(int64_t a, int64_t b, int64_t &result) {
+#if HAVE_DECL___BUILTIN_SSUBLL_OVERFLOW
+        static_assert(std::numeric_limits<long long int>::max() ==
+                      std::numeric_limits<int64_t>::max());
+        long long int tmp_result; // must use long long int due to types
+        if (__builtin_ssubll_overflow(a, b, &tmp_result)) {
+            return true;
+        }
+        result = tmp_result;
+#else
+        if (a < 0 && b > std::numeric_limits<int64_t>::max() + a) {
+            // integer overflow
+            return true;
+        }
+        if (a > 0 && b <= std::numeric_limits<int64_t>::min() + a) {
+            // integer underflow
+            return true;
+        }
+        result = a - b;
+#endif
+        if (result == std::numeric_limits<int64_t>::min()) {
+            return true;
+        }
+        return false;
+    }
+
     int64_t m_value;
 };
 
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -195,6 +195,7 @@
 		script_standard_tests.cpp
 		script_tests.cpp
 		scriptnum_tests.cpp
+		scriptnum63bit_tests.cpp
 		serialize_tests.cpp
 		settings_tests.cpp
 		sigcache_tests.cpp
diff --git a/src/test/scriptnum63bit.h b/src/test/scriptnum63bit.h
new file mode 100644
--- /dev/null
+++ b/src/test/scriptnum63bit.h
@@ -0,0 +1,96 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_TEST_SCRIPTNUM63BIT_H
+#define BITCOIN_TEST_SCRIPTNUM63BIT_H
+
+#include <boost/multiprecision/cpp_int.hpp>
+
+namespace scriptnum_emulated {
+#undef BITCOIN_SCRIPT_SCRIPT_H
+#undef HAVE_DECL___BUILTIN_SADDLL_OVERFLOW
+#undef HAVE_DECL___BUILTIN_SSUBLL_OVERFLOW
+#include <script/script.h>
+} // namespace scriptnum_emulated
+
+typedef boost::multiprecision::checked_int128_t i128_t;
+typedef std::vector<uint8_t> valtype;
+typedef std::vector<valtype> stacktype;
+
+const i128_t MAX_SCRIPT_63_BIT_INT = 0x7fff'ffff'ffff'ffff;
+const i128_t MIN_SCRIPT_63_BIT_INT = -0x7fff'ffff'ffff'ffff;
+
+static const size_t MAXIMUM_63_BIT_ELEMENT_SIZE = 8;
+
+const static std::vector<valtype> INTERESTING_63_BIT_NUMBERS({
+    {}, // 0
+    {1},
+    {0x81}, // -1
+    {2},
+    {0x82}, // -2
+    {4},
+    {0x84}, // -4
+    {10},
+    {0x8a}, // -10
+    {100},
+    {0xe4}, // -100
+    {127},
+    {0xff},       // -127
+    {0, 1},       // 256
+    {0, 0x81},    // -256
+    {0xe8, 0x03}, // 1000
+    {0xe8, 0x83}, // -1000
+    {0xb0, 0x13}, // 5040
+    {0xb0, 0x93}, // -5040
+    {0xff, 0x7f},
+    {0xff, 0xff},
+    {0x00, 0x00, 0x01},
+    {0x00, 0x00, 0x81},
+    {0xff, 0xff, 0x7f},
+    {0xff, 0xff, 0xff},
+    {0x00, 0x00, 0x00, 0x01},
+    {0x00, 0x00, 0x00, 0x81},
+    {0xff, 0xff, 0xff, 0x7f},
+    {0xff, 0xff, 0xff, 0xff},
+    {0x00, 0x00, 0x00, 0x00, 0x01},
+    {0x00, 0x00, 0x00, 0x00, 0x81},
+    {0xff, 0xff, 0xff, 0xff, 0x7f},
+    {0xff, 0xff, 0xff, 0xff, 0xff},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x81},
+    {0xff, 0xff, 0xff, 0xff, 0xff, 0x7f},
+    {0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81},
+    {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f},
+    {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81},
+    {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f},
+    {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+});
+
+static i128_t ToInt128(const valtype &vch) {
+    if (vch.empty()) {
+        return 0;
+    }
+
+    i128_t result = 0;
+    for (size_t i = 0; i < vch.size(); ++i) {
+        if (i == vch.size() - 1 && vch[i] & 0x80) {
+            result |= i128_t(vch[i] & 0x7f) << (8 * i);
+            return -result;
+        }
+        result |= i128_t(vch[i]) << (8 * i);
+    }
+
+    return result;
+}
+
+static bool IsInScriptBounds(const i128_t &num_int) {
+    return num_int >= MIN_SCRIPT_63_BIT_INT && num_int <= MAX_SCRIPT_63_BIT_INT;
+}
+
+#endif // BITCOIN_TEST_SCRIPTNUM63BIT_H
diff --git a/src/test/scriptnum63bit_tests.cpp b/src/test/scriptnum63bit_tests.cpp
new file mode 100644
--- /dev/null
+++ b/src/test/scriptnum63bit_tests.cpp
@@ -0,0 +1,113 @@
+// Copyright (c) 2021 The Bitcoin ABC developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <boost/test/unit_test.hpp>
+#include <test/util/setup_common.h>
+
+#include <functional>
+#include <script/script.h>
+#include <test/lcg.h>
+
+#include <test/scriptnum63bit.h>
+
+BOOST_FIXTURE_TEST_SUITE(scriptnum63bit_tests, BasicTestingSetup)
+
+template <typename TScriptNum>
+static void CheckOperatorsGeneric(const valtype &a_i63, const valtype &b_i63) {
+    const i128_t a_i128 = ToInt128(a_i63);
+    const i128_t b_i128 = ToInt128(b_i63);
+    BOOST_CHECK(IsInScriptBounds(a_i128));
+    BOOST_CHECK(IsInScriptBounds(b_i128));
+    const TScriptNum a((int64_t)a_i128);
+    const TScriptNum b((int64_t)b_i128);
+    {
+        // Test operator+
+        TScriptNum result(0);
+        bool expect_overflow = !IsInScriptBounds(a_i128 + b_i128);
+        try {
+            result = a + b;
+            BOOST_CHECK_MESSAGE(
+                !expect_overflow,
+                strprintf("%d + %d overflowed", a_i128, b_i128));
+        } catch (std::runtime_error &ex) {
+            BOOST_CHECK_MESSAGE(
+                expect_overflow,
+                strprintf("%d + %d didn't overflow", a_i128, b_i128));
+        }
+    }
+    {
+        // Test operator-
+        TScriptNum result(0);
+        bool expect_overflow = !IsInScriptBounds(a_i128 - b_i128);
+        try {
+            result = a - b;
+            BOOST_CHECK_MESSAGE(
+                !expect_overflow,
+                strprintf("%d - %d overflowed", a_i128, b_i128));
+        } catch (std::runtime_error &ex) {
+            BOOST_CHECK_MESSAGE(
+                expect_overflow,
+                strprintf("%d - %d didn't overflow", a_i128, b_i128));
+        }
+    }
+    {
+        // Test operator+=
+        TScriptNum result = a;
+        bool expect_overflow = !IsInScriptBounds(a_i128 + b_i128);
+        try {
+            result += b;
+            BOOST_CHECK_MESSAGE(
+                !expect_overflow,
+                strprintf("%d += %d overflowed", a_i128, b_i128));
+        } catch (std::runtime_error &ex) {
+            BOOST_CHECK_MESSAGE(
+                expect_overflow,
+                strprintf("%d += %d didn't overflow", a_i128, b_i128));
+        }
+    }
+    {
+        // Test operator-=
+        TScriptNum result = a;
+        bool expect_overflow = !IsInScriptBounds(a_i128 - b_i128);
+        try {
+            result -= b;
+            BOOST_CHECK_MESSAGE(
+                !expect_overflow,
+                strprintf("%d -= %d overflowed", a_i128, b_i128));
+        } catch (std::runtime_error &ex) {
+            BOOST_CHECK_MESSAGE(
+                expect_overflow,
+                strprintf("%d -= %d didn't overflow", a_i128, b_i128));
+        }
+    }
+}
+
+static void CheckOperators(const valtype &a_i63, const valtype &b_i63) {
+    CheckOperatorsGeneric<CScriptNum>(a_i63, b_i63);
+    CheckOperatorsGeneric<scriptnum_emulated::CScriptNum>(a_i63, b_i63);
+}
+
+BOOST_AUTO_TEST_CASE(scriptnum_63_bit_arithmetic_test) {
+    MMIXLinearCongruentialGenerator lcg;
+    for (uint32_t test = 0; test < 2048; ++test) {
+        // Generate random numbers between 0 and 8 bytes length.
+        // Byte length is uniformly distributed for better test coverage.
+        uint32_t a_len = lcg.next() % (MAXIMUM_63_BIT_ELEMENT_SIZE + 1);
+        uint32_t b_len = lcg.next() % (MAXIMUM_63_BIT_ELEMENT_SIZE + 1);
+        valtype a_i63(a_len), b_i63(b_len);
+        for (uint32_t i = 0; i < a_len; ++i) {
+            a_i63[i] = lcg.next() % 256;
+        }
+        for (uint32_t i = 0; i < b_len; ++i) {
+            b_i63[i] = lcg.next() % 256;
+        }
+        CheckOperators(a_i63, b_i63);
+        for (const valtype &interesting_num : INTERESTING_63_BIT_NUMBERS) {
+            CheckOperators(a_i63, interesting_num);
+            CheckOperators(interesting_num, b_i63);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/lint/lint-boost-dependencies.sh b/test/lint/lint-boost-dependencies.sh
--- a/test/lint/lint-boost-dependencies.sh
+++ b/test/lint/lint-boost-dependencies.sh
@@ -16,6 +16,7 @@
     boost/date_time/posix_time/posix_time.hpp
     boost/filesystem.hpp
     boost/filesystem/fstream.hpp
+    boost/multiprecision/cpp_int.hpp
     boost/multi_index/composite_key.hpp
     boost/multi_index/hashed_index.hpp
     boost/multi_index/member.hpp