diff --git a/src/compressor.cpp b/src/compressor.cpp
index dd2c07906..acafce3f9 100644
--- a/src/compressor.cpp
+++ b/src/compressor.cpp
@@ -1,185 +1,193 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2014 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <compressor.h>
 
 #include <hash.h>
 #include <pubkey.h>
 #include <script/standard.h>
 
-bool CScriptCompressor::IsToKeyID(CKeyID &hash) const {
+/*
+ * These check for scripts for which a special case with a shorter encoding is
+ * defined. They are implemented separately from the CScript test, as these test
+ * for exact byte sequence correspondences, and are more strict. For example,
+ * IsToPubKey also verifies whether the public key is valid (as invalid ones
+ * cannot be represented in compressed form).
+ */
+
+static bool IsToKeyID(const CScript &script, CKeyID &hash) {
     if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 &&
         script[2] == 20 && script[23] == OP_EQUALVERIFY &&
         script[24] == OP_CHECKSIG) {
         memcpy(&hash, &script[3], 20);
         return true;
     }
     return false;
 }
 
-bool CScriptCompressor::IsToScriptID(CScriptID &hash) const {
+static bool IsToScriptID(const CScript &script, CScriptID &hash) {
     if (script.size() == 23 && script[0] == OP_HASH160 && script[1] == 20 &&
         script[22] == OP_EQUAL) {
         memcpy(&hash, &script[2], 20);
         return true;
     }
     return false;
 }
 
-bool CScriptCompressor::IsToPubKey(CPubKey &pubkey) const {
+static bool IsToPubKey(const CScript &script, CPubKey &pubkey) {
     if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG &&
         (script[1] == 0x02 || script[1] == 0x03)) {
         pubkey.Set(&script[1], &script[34]);
         return true;
     }
     if (script.size() == 67 && script[0] == 65 && script[66] == OP_CHECKSIG &&
         script[1] == 0x04) {
         pubkey.Set(&script[1], &script[66]);
         // if not fully valid, a case that would not be compressible
         return pubkey.IsFullyValid();
     }
     return false;
 }
 
-bool CScriptCompressor::Compress(std::vector<uint8_t> &out) const {
+bool CompressScript(const CScript &script, std::vector<uint8_t> &out) {
     CKeyID keyID;
-    if (IsToKeyID(keyID)) {
+    if (IsToKeyID(script, keyID)) {
         out.resize(21);
         out[0] = 0x00;
         memcpy(&out[1], &keyID, 20);
         return true;
     }
     CScriptID scriptID;
-    if (IsToScriptID(scriptID)) {
+    if (IsToScriptID(script, scriptID)) {
         out.resize(21);
         out[0] = 0x01;
         memcpy(&out[1], &scriptID, 20);
         return true;
     }
     CPubKey pubkey;
-    if (IsToPubKey(pubkey)) {
+    if (IsToPubKey(script, pubkey)) {
         out.resize(33);
         memcpy(&out[1], &pubkey[1], 32);
         if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {
             out[0] = pubkey[0];
             return true;
         } else if (pubkey[0] == 0x04) {
             out[0] = 0x04 | (pubkey[64] & 0x01);
             return true;
         }
     }
     return false;
 }
 
-unsigned int CScriptCompressor::GetSpecialSize(unsigned int nSize) const {
+unsigned int GetSpecialScriptSize(unsigned int nSize) {
     if (nSize == 0 || nSize == 1) {
         return 20;
     }
     if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5) {
         return 32;
     }
     return 0;
 }
 
-bool CScriptCompressor::Decompress(unsigned int nSize,
-                                   const std::vector<uint8_t> &in) {
+bool DecompressScript(CScript &script, unsigned int nSize,
+                      const std::vector<uint8_t> &in) {
     switch (nSize) {
         case 0x00:
             script.resize(25);
             script[0] = OP_DUP;
             script[1] = OP_HASH160;
             script[2] = 20;
             memcpy(&script[3], in.data(), 20);
             script[23] = OP_EQUALVERIFY;
             script[24] = OP_CHECKSIG;
             return true;
         case 0x01:
             script.resize(23);
             script[0] = OP_HASH160;
             script[1] = 20;
             memcpy(&script[2], in.data(), 20);
             script[22] = OP_EQUAL;
             return true;
         case 0x02:
         case 0x03:
             script.resize(35);
             script[0] = 33;
             script[1] = nSize;
             memcpy(&script[2], in.data(), 32);
             script[34] = OP_CHECKSIG;
             return true;
         case 0x04:
         case 0x05:
             uint8_t vch[33] = {};
             vch[0] = nSize - 2;
             memcpy(&vch[1], in.data(), 32);
             CPubKey pubkey(&vch[0], &vch[33]);
             if (!pubkey.Decompress()) return false;
             assert(pubkey.size() == 65);
             script.resize(67);
             script[0] = 65;
             memcpy(&script[1], pubkey.begin(), 65);
             script[66] = OP_CHECKSIG;
             return true;
     }
     return false;
 }
 
 // Amount compression:
 // * If the amount is 0, output 0
 // * first, divide the amount (in base units) by the largest power of 10
 // possible; call the exponent e (e is max 9)
 // * if e<9, the last digit of the resulting number cannot be 0; store it as d,
 // and drop it (divide by 10)
 //   * call the result n
 //   * output 1 + 10*(9*n + d - 1) + e
 // * if e==9, we only know the resulting number is not zero, so output 1 + 10*(n
 // - 1) + 9
 // (this is decodable, as d is in [1-9] and e is in [0-9])
-uint64_t CTxOutCompressor::CompressAmount(Amount amt) {
+uint64_t CompressAmount(Amount amt) {
     uint64_t n = amt / SATOSHI;
     if (n == 0) {
         return 0;
     }
     int e = 0;
     while (((n % 10) == 0) && e < 9) {
         n /= 10;
         e++;
     }
     if (e < 9) {
         int d = (n % 10);
         assert(d >= 1 && d <= 9);
         n /= 10;
         return 1 + (n * 9 + d - 1) * 10 + e;
     } else {
         return 1 + (n - 1) * 10 + 9;
     }
 }
 
-Amount CTxOutCompressor::DecompressAmount(uint64_t x) {
+Amount DecompressAmount(uint64_t x) {
     // x = 0  OR  x = 1+10*(9*n + d - 1) + e  OR  x = 1+10*(n - 1) + 9
     if (x == 0) {
         return Amount::zero();
     }
     x--;
     // x = 10*(9*n + d - 1) + e
     int e = x % 10;
     x /= 10;
     uint64_t n = 0;
     if (e < 9) {
         // x = 9*n + d - 1
         int d = (x % 9) + 1;
         x /= 9;
         // x = n
         n = x * 10 + d;
     } else {
         n = x + 1;
     }
     while (e) {
         n *= 10;
         e--;
     }
     return int64_t(n) * SATOSHI;
 }
diff --git a/src/compressor.h b/src/compressor.h
index 286c2eb41..c0506fa03 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -1,120 +1,109 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 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_COMPRESSOR_H
 #define BITCOIN_COMPRESSOR_H
 
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <serialize.h>
 
 class CKeyID;
 class CPubKey;
 class CScriptID;
 
+bool CompressScript(const CScript &script, std::vector<uint8_t> &out);
+unsigned int GetSpecialScriptSize(unsigned int nSize);
+bool DecompressScript(CScript &script, unsigned int nSize,
+                      const std::vector<uint8_t> &out);
+
+uint64_t CompressAmount(Amount nAmount);
+Amount DecompressAmount(uint64_t nAmount);
+
 /**
  * Compact serializer for scripts.
  *
  * It detects common cases and encodes them much more efficiently.
  * 3 special cases are defined:
  *  * Pay to pubkey hash (encoded as 21 bytes)
  *  * Pay to script hash (encoded as 21 bytes)
  *  * Pay to pubkey starting with 0x02, 0x03 or 0x04 (encoded as 33 bytes)
  *
  * Other scripts up to 121 bytes require 1 byte + script length. Above that,
  * scripts up to 16505 bytes require 2 bytes + script length.
  */
 class CScriptCompressor {
 private:
     /**
      * make this static for now (there are only 6 special scripts defined) this
      * can potentially be extended together with a new nVersion for
      * transactions, in which case this value becomes dependent on nVersion and
      * nHeight of the enclosing transaction.
      */
     static const unsigned int nSpecialScripts = 6;
 
     CScript &script;
 
-protected:
-    /**
-     * These check for scripts for which a special case with a shorter encoding
-     * is defined. They are implemented separately from the CScript test, as
-     * these test for exact byte sequence correspondences, and are more strict.
-     * For example, IsToPubKey also verifies whether the public key is valid (as
-     * invalid ones cannot be represented in compressed form).
-     */
-    bool IsToKeyID(CKeyID &hash) const;
-    bool IsToScriptID(CScriptID &hash) const;
-    bool IsToPubKey(CPubKey &pubkey) const;
-
-    bool Compress(std::vector<uint8_t> &out) const;
-    unsigned int GetSpecialSize(unsigned int nSize) const;
-    bool Decompress(unsigned int nSize, const std::vector<uint8_t> &out);
-
 public:
     explicit CScriptCompressor(CScript &scriptIn) : script(scriptIn) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         std::vector<uint8_t> compr;
-        if (Compress(compr)) {
+        if (CompressScript(script, compr)) {
             s << CFlatData(compr);
             return;
         }
         unsigned int nSize = script.size() + nSpecialScripts;
         s << VARINT(nSize);
         s << CFlatData(script);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         unsigned int nSize = 0;
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
-            std::vector<uint8_t> vch(GetSpecialSize(nSize), 0x00);
+            std::vector<uint8_t> vch(GetSpecialScriptSize(nSize), 0x00);
             s >> CFlatData(vch);
-            Decompress(nSize, vch);
+            DecompressScript(script, nSize, vch);
             return;
         }
         nSize -= nSpecialScripts;
         if (nSize > MAX_SCRIPT_SIZE) {
             // Overly long script, replace with a short invalid one
             script << OP_RETURN;
             s.ignore(nSize);
         } else {
             script.resize(nSize);
             s >> CFlatData(script);
         }
     }
 };
 
 /** wrapper for CTxOut that provides a more compact serialization */
 class CTxOutCompressor {
 private:
     CTxOut &txout;
 
 public:
-    static uint64_t CompressAmount(Amount nAmount);
-    static Amount DecompressAmount(uint64_t nAmount);
-
     explicit CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         if (!ser_action.ForRead()) {
             uint64_t nVal = CompressAmount(txout.nValue);
             READWRITE(VARINT(nVal));
         } else {
             uint64_t nVal = 0;
             READWRITE(VARINT(nVal));
             txout.nValue = DecompressAmount(nVal);
         }
         CScriptCompressor cscript(REF(txout.scriptPubKey));
         READWRITE(cscript);
     }
 };
 
 #endif // BITCOIN_COMPRESSOR_H
diff --git a/src/test/compress_tests.cpp b/src/test/compress_tests.cpp
index de2021914..f5ccb56c3 100644
--- a/src/test/compress_tests.cpp
+++ b/src/test/compress_tests.cpp
@@ -1,73 +1,70 @@
 // Copyright (c) 2012-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.
 
 #include <compressor.h>
 
 #include <util.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <cstdint>
 
 // amounts 0.00000001 .. 0.00100000
 #define NUM_MULTIPLES_UNIT 100000
 
 // amounts 0.01 .. 100.00
 #define NUM_MULTIPLES_CENT 10000
 
 // amounts 1 .. 10000
 #define NUM_MULTIPLES_1BCH 10000
 
 // amounts 50 .. 21000000
 #define NUM_MULTIPLES_50BCH 420000
 
 BOOST_FIXTURE_TEST_SUITE(compress_tests, BasicTestingSetup)
 
 static bool TestEncode(Amount in) {
-    return in == CTxOutCompressor::DecompressAmount(
-                     CTxOutCompressor::CompressAmount(in));
+    return in == DecompressAmount(CompressAmount(in));
 }
 
 static bool TestDecode(uint64_t in) {
-    return in == CTxOutCompressor::CompressAmount(
-                     CTxOutCompressor::DecompressAmount(in));
+    return in == CompressAmount(DecompressAmount(in));
 }
 
 static bool TestPair(Amount dec, uint64_t enc) {
-    return CTxOutCompressor::CompressAmount(dec) == enc &&
-           CTxOutCompressor::DecompressAmount(enc) == dec;
+    return CompressAmount(dec) == enc && DecompressAmount(enc) == dec;
 }
 
 BOOST_AUTO_TEST_CASE(compress_amounts) {
     BOOST_CHECK(TestPair(Amount::zero(), 0x0));
     BOOST_CHECK(TestPair(SATOSHI, 0x1));
     BOOST_CHECK(TestPair(CENT, 0x7));
     BOOST_CHECK(TestPair(COIN, 0x9));
     BOOST_CHECK(TestPair(50 * COIN, 0x32));
     BOOST_CHECK(TestPair(21000000 * COIN, 0x1406f40));
 
     for (int64_t i = 1; i <= NUM_MULTIPLES_UNIT; i++) {
         BOOST_CHECK(TestEncode(i * SATOSHI));
     }
 
     for (int64_t i = 1; i <= NUM_MULTIPLES_CENT; i++) {
         BOOST_CHECK(TestEncode(i * CENT));
     }
 
     for (int64_t i = 1; i <= NUM_MULTIPLES_1BCH; i++) {
         BOOST_CHECK(TestEncode(i * COIN));
     }
 
     for (int64_t i = 1; i <= NUM_MULTIPLES_50BCH; i++) {
         BOOST_CHECK(TestEncode(i * 50 * COIN));
     }
 
     for (int64_t i = 0; i < 100000; i++) {
         BOOST_CHECK(TestDecode(i));
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()