diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -308,6 +308,7 @@
 	primitives/transaction.cpp
 	pubkey.cpp
 	script/bitcoinconsensus.cpp
+	script/bitfield.cpp
 	script/interpreter.cpp
 	script/script.cpp
 	script/script_error.cpp
diff --git a/src/Makefile.am b/src/Makefile.am
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -389,6 +389,8 @@
   pubkey.cpp \
   pubkey.h \
   script/bitcoinconsensus.cpp \
+  script/bitfield.cpp \
+  script/bitfield.h \
   script/sighashtype.h \
   script/interpreter.cpp \
   script/interpreter.h \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -101,6 +101,7 @@
   test/scheduler_tests.cpp \
   test/schnorr_tests.cpp \
   test/script_commitment_tests.cpp \
+  test/script_bitfield_tests.cpp \
   test/script_p2sh_tests.cpp \
   test/script_standard_tests.cpp \
   test/script_tests.cpp \
diff --git a/src/script/bitfield.h b/src/script/bitfield.h
new file mode 100644
--- /dev/null
+++ b/src/script/bitfield.h
@@ -0,0 +1,16 @@
+// Copyright (c) 2019 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_SCRIPT_BITFIELD_H
+#define BITCOIN_SCRIPT_BITFIELD_H
+
+#include <cstdint>
+#include <vector>
+
+enum class ScriptError;
+
+bool DecodeBitfield(const std::vector<uint8_t> &vch, unsigned size,
+                    uint32_t &bitfield, ScriptError *serror);
+
+#endif // BITCOIN_SCRIPT_BITFIELD_H
diff --git a/src/script/bitfield.cpp b/src/script/bitfield.cpp
new file mode 100644
--- /dev/null
+++ b/src/script/bitfield.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) 2019 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <script/bitfield.h>
+
+#include <script/script_error.h>
+
+#include <cstddef>
+#include <limits>
+
+bool DecodeBitfield(const std::vector<uint8_t> &vch, unsigned size,
+                    uint32_t &bitfield, ScriptError *serror) {
+    if (size > 32) {
+        return set_error(serror, ScriptError::INVALID_BITFIELD_SIZE);
+    }
+
+    const size_t bitfield_size = (size + 7) / 8;
+    if (vch.size() != bitfield_size) {
+        return set_error(serror, ScriptError::INVALID_BITFIELD_SIZE);
+    }
+
+    bitfield = 0;
+    for (size_t i = 0; i < bitfield_size; i++) {
+        // Decode the bitfield as little endian.
+        bitfield |= uint32_t(vch[i]) << (8 * i);
+    }
+
+    const uint32_t mask = (uint64_t(1) << size) - 1;
+    if ((bitfield & mask) != bitfield) {
+        return set_error(serror, ScriptError::INVALID_BIT_RANGE);
+    }
+
+    return true;
+}
diff --git a/src/script/script_error.h b/src/script/script_error.h
--- a/src/script/script_error.h
+++ b/src/script/script_error.h
@@ -45,6 +45,10 @@
     DIV_BY_ZERO,
     MOD_BY_ZERO,
 
+    /* Bitfield errors */
+    INVALID_BITFIELD_SIZE,
+    INVALID_BIT_RANGE,
+
     /* CHECKLOCKTIMEVERIFY and CHECKSEQUENCEVERIFY */
     NEGATIVE_LOCKTIME,
     UNSATISFIED_LOCKTIME,
diff --git a/src/script/script_error.cpp b/src/script/script_error.cpp
--- a/src/script/script_error.cpp
+++ b/src/script/script_error.cpp
@@ -61,6 +61,10 @@
             return "Division by zero error";
         case ScriptError::MOD_BY_ZERO:
             return "Modulo by zero error";
+        case ScriptError::INVALID_BITFIELD_SIZE:
+            return "Bitfield of unexpected size error";
+        case ScriptError::INVALID_BIT_RANGE:
+            return "Bitfield's bit out of the expected range";
         case ScriptError::NEGATIVE_LOCKTIME:
             return "Negative locktime";
         case ScriptError::UNSATISFIED_LOCKTIME:
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -112,6 +112,7 @@
 	sanity_tests.cpp
 	scheduler_tests.cpp
 	schnorr_tests.cpp
+	script_bitfield_tests.cpp
 	script_commitment_tests.cpp
 	script_p2sh_tests.cpp
 	script_standard_tests.cpp
diff --git a/src/test/script_bitfield_tests.cpp b/src/test/script_bitfield_tests.cpp
new file mode 100644
--- /dev/null
+++ b/src/test/script_bitfield_tests.cpp
@@ -0,0 +1,107 @@
+// Copyright (c) 2019 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <script/bitfield.h>
+#include <script/script_error.h>
+#include <test/test_bitcoin.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(script_bitfield_tests, BasicTestingSetup)
+
+static void CheckBitFieldFailure(const std::vector<uint8_t> &vch, unsigned size,
+                                 ScriptError expected_error) {
+    uint32_t bitfield;
+    ScriptError serror = ScriptError::OK;
+
+    // First check that size larger than 32 get rejected.
+    BOOST_CHECK(!DecodeBitfield(vch, size, bitfield, &serror));
+    BOOST_CHECK(serror == expected_error);
+}
+
+static void CheckBitFieldSuccess(const std::vector<uint8_t> &vch, unsigned size,
+                                 uint32_t result) {
+    uint32_t bitfield;
+    ScriptError serror = ScriptError::OK;
+
+    // First check that size larger than 32 get rejected.
+    BOOST_CHECK(DecodeBitfield(vch, size, bitfield, &serror));
+    BOOST_CHECK_EQUAL(bitfield, result);
+    BOOST_CHECK(serror == ScriptError::OK);
+
+    // One more byte and the test case is invalid.
+    std::vector<uint8_t> copy = vch;
+    copy.push_back(0x00);
+    CheckBitFieldFailure(copy, size, ScriptError::INVALID_BITFIELD_SIZE);
+    copy.pop_back();
+
+    // One less byte and the test case is also invalid.
+    while (copy.size() > 0) {
+        copy.pop_back();
+        CheckBitFieldFailure(copy, size, ScriptError::INVALID_BITFIELD_SIZE);
+    }
+
+    // Pop the first element and recurse.
+    if (size >= 8) {
+        copy = vch;
+        copy.erase(copy.begin());
+        CheckBitFieldSuccess(copy, size - 8, result >> 8);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(decode_bitfield) {
+    // Size 0 => empty bitfield.
+    CheckBitFieldSuccess({}, 0, 0);
+
+    // Size 1 to 8 => 1 byte bitfield.
+    for (unsigned i = 1; i <= 8; i++) {
+        CheckBitFieldSuccess({0x00}, i, 0);
+    }
+
+    // Size 9 to 16 => 2 bytes bitfield.
+    for (unsigned i = 9; i <= 16; i++) {
+        CheckBitFieldSuccess({0x00, 0x00}, i, 0);
+    }
+
+    // Size 17 to 24 => 3 bytes bitfield.
+    for (unsigned i = 17; i <= 24; i++) {
+        CheckBitFieldSuccess({0x00, 0x00, 0x00}, i, 0);
+    }
+
+    // Size 25 to 32 => 3 bytes bitfield.
+    for (unsigned i = 25; i <= 32; i++) {
+        CheckBitFieldSuccess({0x00, 0x00, 0x00, 0x00}, i, 0);
+    }
+
+    // Size greater than 32 => failure.
+    for (unsigned i = 33; i <= 100; i++) {
+        CheckBitFieldFailure({0x00, 0x00, 0x00, 0x00, 0x00}, i,
+                             ScriptError::INVALID_BITFIELD_SIZE);
+    }
+
+    // Check various bit patterns.
+    CheckBitFieldSuccess({0xff, 0xff, 0xff, 0xff}, 32, 0xffffffff);
+    CheckBitFieldSuccess({0x98, 0xba, 0xdc, 0xfe}, 32, 0xfedcba98);
+    CheckBitFieldSuccess({0xef, 0xbe, 0xad, 0xde}, 32, 0xdeadbeef);
+    CheckBitFieldSuccess({0xa5, 0xa5, 0xa5, 0xa5}, 32, 0xa5a5a5a5);
+    CheckBitFieldSuccess({0x5a, 0x5a, 0x5a, 0x5a}, 32, 0x5a5a5a5a);
+
+    // More valid bit patterns.
+    for (unsigned i = 1; i <= 8; i++) {
+        uint8_t first = (1 << i) - 1;
+        CheckBitFieldSuccess({0x56, 0x34, 0x12, first}, 24 + i,
+                             (0x123456 | (first << 24)));
+    }
+
+    // Out of range bits.
+    for (unsigned i = 1; i < 8; i++) {
+        const uint8_t first = (1 << i) - 1;
+        for (unsigned j = i; j < 8; j++) {
+            CheckBitFieldFailure({0x56, 0x34, 0x12, uint8_t(first | (1 << j))},
+                                 24 + i, ScriptError::INVALID_BIT_RANGE);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()