diff --git a/src/keystore.cpp b/src/keystore.cpp
index 4eee90a55..19c14605f 100644
--- a/src/keystore.cpp
+++ b/src/keystore.cpp
@@ -1,175 +1,175 @@
 // 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.
 
 #include <keystore.h>
 
 #include <key.h>
 #include <pubkey.h>
 #include <util.h>
 
 bool CKeyStore::AddKey(const CKey &key) {
     return AddKeyPubKey(key, key.GetPubKey());
 }
 
 void CBasicKeyStore::ImplicitlyLearnRelatedKeyScripts(const CPubKey &pubkey) {
     AssertLockHeld(cs_KeyStore);
     CKeyID key_id = pubkey.GetID();
     // We must actually know about this key already.
     assert(HaveKey(key_id) || mapWatchKeys.count(key_id));
     // This adds the redeemscripts necessary to detect alternative outputs using
     // the same keys. Also note that having superfluous scripts in the keystore
     // never hurts. They're only used to guide recursion in signing and IsMine
     // logic - if a script is present but we can't do anything with it, it has
     // no effect. "Implicitly" refers to fact that scripts are derived
     // automatically from existing keys, and are present in memory, even without
     // being explicitly loaded (e.g. from a file).
 
     // Right now there are none so do nothing.
 }
 
 bool CBasicKeyStore::GetPubKey(const CKeyID &address,
                                CPubKey &vchPubKeyOut) const {
     CKey key;
     if (!GetKey(address, key)) {
         LOCK(cs_KeyStore);
         WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
         if (it != mapWatchKeys.end()) {
             vchPubKeyOut = it->second;
             return true;
         }
         return false;
     }
     vchPubKeyOut = key.GetPubKey();
     return true;
 }
 
 bool CBasicKeyStore::AddKeyPubKey(const CKey &key, const CPubKey &pubkey) {
     LOCK(cs_KeyStore);
     mapKeys[pubkey.GetID()] = key;
     ImplicitlyLearnRelatedKeyScripts(pubkey);
     return true;
 }
 
 bool CBasicKeyStore::HaveKey(const CKeyID &address) const {
     LOCK(cs_KeyStore);
     return mapKeys.count(address) > 0;
 }
 
 std::set<CKeyID> CBasicKeyStore::GetKeys() const {
     LOCK(cs_KeyStore);
     std::set<CKeyID> set_address;
     for (const auto &mi : mapKeys) {
         set_address.insert(mi.first);
     }
     return set_address;
 }
 
 bool CBasicKeyStore::GetKey(const CKeyID &address, CKey &keyOut) const {
     LOCK(cs_KeyStore);
     KeyMap::const_iterator mi = mapKeys.find(address);
     if (mi != mapKeys.end()) {
         keyOut = mi->second;
         return true;
     }
     return false;
 }
 
 bool CBasicKeyStore::AddCScript(const CScript &redeemScript) {
     if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         return error("CBasicKeyStore::AddCScript(): redeemScripts > %i bytes "
                      "are invalid",
                      MAX_SCRIPT_ELEMENT_SIZE);
     }
 
     LOCK(cs_KeyStore);
     mapScripts[CScriptID(redeemScript)] = redeemScript;
     return true;
 }
 
 bool CBasicKeyStore::HaveCScript(const CScriptID &hash) const {
     LOCK(cs_KeyStore);
     return mapScripts.count(hash) > 0;
 }
 
 std::set<CScriptID> CBasicKeyStore::GetCScripts() const {
     LOCK(cs_KeyStore);
     std::set<CScriptID> set_script;
     for (const auto &mi : mapScripts) {
         set_script.insert(mi.first);
     }
     return set_script;
 }
 
 bool CBasicKeyStore::GetCScript(const CScriptID &hash,
                                 CScript &redeemScriptOut) const {
     LOCK(cs_KeyStore);
     ScriptMap::const_iterator mi = mapScripts.find(hash);
     if (mi != mapScripts.end()) {
         redeemScriptOut = (*mi).second;
         return true;
     }
     return false;
 }
 
 static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut) {
     // TODO: Use Solver to extract this?
     CScript::const_iterator pc = dest.begin();
     opcodetype opcode;
     std::vector<uint8_t> vch;
-    if (!dest.GetOp(pc, opcode, vch) || vch.size() < 33 || vch.size() > 65) {
+    if (!dest.GetOp(pc, opcode, vch) || !CPubKey::ValidSize(vch)) {
         return false;
     }
     pubKeyOut = CPubKey(vch);
     if (!pubKeyOut.IsFullyValid()) {
         return false;
     }
     if (!dest.GetOp(pc, opcode, vch) || opcode != OP_CHECKSIG ||
         dest.GetOp(pc, opcode, vch)) {
         return false;
     }
     return true;
 }
 
 bool CBasicKeyStore::AddWatchOnly(const CScript &dest) {
     LOCK(cs_KeyStore);
     setWatchOnly.insert(dest);
     CPubKey pubKey;
     if (ExtractPubKey(dest, pubKey)) {
         mapWatchKeys[pubKey.GetID()] = pubKey;
         ImplicitlyLearnRelatedKeyScripts(pubKey);
     }
     return true;
 }
 
 bool CBasicKeyStore::RemoveWatchOnly(const CScript &dest) {
     LOCK(cs_KeyStore);
     setWatchOnly.erase(dest);
     CPubKey pubKey;
     if (ExtractPubKey(dest, pubKey)) {
         mapWatchKeys.erase(pubKey.GetID());
     }
     // Related CScripts are not removed; having superfluous scripts around is
     // harmless (see comment in ImplicitlyLearnRelatedKeyScripts).
     return true;
 }
 
 bool CBasicKeyStore::HaveWatchOnly(const CScript &dest) const {
     LOCK(cs_KeyStore);
     return setWatchOnly.count(dest) > 0;
 }
 
 bool CBasicKeyStore::HaveWatchOnly() const {
     LOCK(cs_KeyStore);
     return (!setWatchOnly.empty());
 }
 
 CKeyID GetKeyForDestination(const CKeyStore &store,
                             const CTxDestination &dest) {
     // Only supports destinations which map to single public keys, i.e. P2PKH.
     if (auto id = boost::get<CKeyID>(&dest)) {
         return *id;
     }
     return CKeyID();
 }
diff --git a/src/pubkey.h b/src/pubkey.h
index 599aad7c1..e468b7179 100644
--- a/src/pubkey.h
+++ b/src/pubkey.h
@@ -1,240 +1,244 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017 The Zcash developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_PUBKEY_H
 #define BITCOIN_PUBKEY_H
 
 #include <hash.h>
 #include <serialize.h>
 #include <uint256.h>
 
 #include <boost/range/adaptor/sliced.hpp>
 
 #include <stdexcept>
 #include <vector>
 
 const unsigned int BIP32_EXTKEY_SIZE = 74;
 
 /** A reference to a CKey: the Hash160 of its serialized public key */
 class CKeyID : public uint160 {
 public:
     CKeyID() : uint160() {}
     explicit CKeyID(const uint160 &in) : uint160(in) {}
 };
 
 typedef uint256 ChainCode;
 
 /** An encapsulated public key. */
 class CPubKey {
 public:
     /**
      * secp256k1:
      */
     static const unsigned int PUBLIC_KEY_SIZE = 65;
     static const unsigned int COMPRESSED_PUBLIC_KEY_SIZE = 33;
     static const unsigned int SIGNATURE_SIZE = 72;
     static const unsigned int COMPACT_SIGNATURE_SIZE = 65;
     /**
      * see www.keylength.com
      * script supports up to 75 for single byte push
      */
     static_assert(PUBLIC_KEY_SIZE >= COMPRESSED_PUBLIC_KEY_SIZE,
                   "COMPRESSED_PUBLIC_KEY_SIZE is larger than PUBLIC_KEY_SIZE");
 
 private:
     /**
      * Just store the serialized data.
      * Its length can very cheaply be computed from the first byte.
      */
     uint8_t vch[PUBLIC_KEY_SIZE];
 
     //! Compute the length of a pubkey with a given first byte.
     static unsigned int GetLen(uint8_t chHeader) {
         if (chHeader == 2 || chHeader == 3) {
             return COMPRESSED_PUBLIC_KEY_SIZE;
         }
         if (chHeader == 4 || chHeader == 6 || chHeader == 7) {
             return PUBLIC_KEY_SIZE;
         }
         return 0;
     }
 
     //! Set this key data to be invalid
     void Invalidate() { vch[0] = 0xFF; }
 
 public:
+    bool static ValidSize(const std::vector<uint8_t> &vch) {
+        return vch.size() > 0 && GetLen(vch[0]) == vch.size();
+    }
+
     //! Construct an invalid public key.
     CPubKey() { Invalidate(); }
 
     //! Initialize a public key using begin/end iterators to byte data.
     template <typename T> void Set(const T pbegin, const T pend) {
         int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
         if (len && len == (pend - pbegin)) {
             memcpy(vch, (uint8_t *)&pbegin[0], len);
         } else {
             Invalidate();
         }
     }
 
     //! Construct a public key using begin/end iterators to byte data.
     template <typename T> CPubKey(const T pbegin, const T pend) {
         Set(pbegin, pend);
     }
 
     //! Construct a public key from a byte vector.
     explicit CPubKey(const std::vector<uint8_t> &_vch) {
         Set(_vch.begin(), _vch.end());
     }
 
     //! Simple read-only vector-like interface to the pubkey data.
     unsigned int size() const { return GetLen(vch[0]); }
     const uint8_t *begin() const { return vch; }
     const uint8_t *end() const { return vch + size(); }
     const uint8_t &operator[](unsigned int pos) const { return vch[pos]; }
 
     //! Comparator implementation.
     friend bool operator==(const CPubKey &a, const CPubKey &b) {
         return a.vch[0] == b.vch[0] && memcmp(a.vch, b.vch, a.size()) == 0;
     }
     friend bool operator!=(const CPubKey &a, const CPubKey &b) {
         return !(a == b);
     }
     friend bool operator<(const CPubKey &a, const CPubKey &b) {
         return a.vch[0] < b.vch[0] ||
                (a.vch[0] == b.vch[0] && memcmp(a.vch, b.vch, a.size()) < 0);
     }
 
     //! Implement serialization, as if this was a byte vector.
     template <typename Stream> void Serialize(Stream &s) const {
         unsigned int len = size();
         ::WriteCompactSize(s, len);
         s.write((char *)vch, len);
     }
     template <typename Stream> void Unserialize(Stream &s) {
         unsigned int len = ::ReadCompactSize(s);
         if (len <= PUBLIC_KEY_SIZE) {
             s.read((char *)vch, len);
         } else {
             // invalid pubkey, skip available data
             char dummy;
             while (len--) {
                 s.read(&dummy, 1);
             }
             Invalidate();
         }
     }
 
     //! Get the KeyID of this public key (hash of its serialization)
     CKeyID GetID() const { return CKeyID(Hash160(vch, vch + size())); }
 
     //! Get the 256-bit hash of this public key.
     uint256 GetHash() const { return Hash(vch, vch + size()); }
 
     /*
      * Check syntactic correctness.
      *
      * Note that this is consensus critical as CheckSig() calls it!
      */
     bool IsValid() const { return size() > 0; }
 
     //! fully validate whether this is a valid public key (more expensive than
     //! IsValid())
     bool IsFullyValid() const;
 
     //! Check whether this is a compressed public key.
     bool IsCompressed() const { return size() == COMPRESSED_PUBLIC_KEY_SIZE; }
 
     /**
      * Verify a DER-serialized ECDSA signature (~72 bytes).
      * If this public key is not fully valid, the return value will be false.
      */
     bool VerifyECDSA(const uint256 &hash,
                      const std::vector<uint8_t> &vchSig) const;
 
     /**
      * Verify a Schnorr signature (=64 bytes).
      * If this public key is not fully valid, the return value will be false.
      */
     bool VerifySchnorr(const uint256 &hash,
                        const std::vector<uint8_t> &vchSig) const;
 
     /**
      * Check whether a DER-serialized ECDSA signature is normalized (lower-S).
      */
     static bool
     CheckLowS(const boost::sliced_range<const std::vector<uint8_t>> &vchSig);
     static bool CheckLowS(const std::vector<uint8_t> &vchSig) {
         return CheckLowS(vchSig | boost::adaptors::sliced(0, vchSig.size()));
     }
 
     //! Recover a public key from a compact ECDSA signature.
     bool RecoverCompact(const uint256 &hash,
                         const std::vector<uint8_t> &vchSig);
 
     //! Turn this public key into an uncompressed public key.
     bool Decompress();
 
     //! Derive BIP32 child pubkey.
     bool Derive(CPubKey &pubkeyChild, ChainCode &ccChild, unsigned int nChild,
                 const ChainCode &cc) const;
 };
 
 struct CExtPubKey {
     uint8_t nDepth;
     uint8_t vchFingerprint[4];
     unsigned int nChild;
     ChainCode chaincode;
     CPubKey pubkey;
 
     friend bool operator==(const CExtPubKey &a, const CExtPubKey &b) {
         return a.nDepth == b.nDepth &&
                memcmp(&a.vchFingerprint[0], &b.vchFingerprint[0],
                       sizeof(vchFingerprint)) == 0 &&
                a.nChild == b.nChild && a.chaincode == b.chaincode &&
                a.pubkey == b.pubkey;
     }
 
     void Encode(uint8_t code[BIP32_EXTKEY_SIZE]) const;
     void Decode(const uint8_t code[BIP32_EXTKEY_SIZE]);
     bool Derive(CExtPubKey &out, unsigned int nChild) const;
 
     void Serialize(CSizeComputer &s) const {
         // Optimized implementation for ::GetSerializeSize that avoids copying.
         // add one byte for the size (compact int)
         s.seek(BIP32_EXTKEY_SIZE + 1);
     }
     template <typename Stream> void Serialize(Stream &s) const {
         unsigned int len = BIP32_EXTKEY_SIZE;
         ::WriteCompactSize(s, len);
         uint8_t code[BIP32_EXTKEY_SIZE];
         Encode(code);
         s.write((const char *)&code[0], len);
     }
     template <typename Stream> void Unserialize(Stream &s) {
         unsigned int len = ::ReadCompactSize(s);
         if (len != BIP32_EXTKEY_SIZE) {
             throw std::runtime_error("Invalid extended key size\n");
         }
 
         uint8_t code[BIP32_EXTKEY_SIZE];
         s.read((char *)&code[0], len);
         Decode(code);
     }
 };
 
 /**
  * Users of this module must hold an ECCVerifyHandle. The constructor and
  * destructor of these are not allowed to run in parallel, though.
  */
 class ECCVerifyHandle {
     static int refcount;
 
 public:
     ECCVerifyHandle();
     ~ECCVerifyHandle();
 };
 
 #endif // BITCOIN_PUBKEY_H
diff --git a/src/script/sigencoding.cpp b/src/script/sigencoding.cpp
index 49270c9f5..7789a9f04 100644
--- a/src/script/sigencoding.cpp
+++ b/src/script/sigencoding.cpp
@@ -1,330 +1,330 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2018 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/sigencoding.h>
 
 #include <pubkey.h>
 #include <script/script_flags.h>
 
 #include <boost/range/adaptor/sliced.hpp>
 
 typedef boost::sliced_range<const valtype> slicedvaltype;
 
 /**
  * A canonical signature exists of: <30> <total len> <02> <len R> <R> <02> <len
  * S> <S>, where R and S are not negative (their first byte has its highest bit
  * not set), and not excessively padded (do not start with a 0 byte, unless an
  * otherwise negative number follows, in which case a single 0 byte is
  * necessary and even required).
  *
  * See https://bitcointalk.org/index.php?topic=8392.msg127623#msg127623
  *
  * This function is consensus-critical since BIP66.
  */
 static bool IsValidDERSignatureEncoding(const slicedvaltype &sig) {
     // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
     // * total-length: 1-byte length descriptor of everything that follows,
     // excluding the sighash byte.
     // * R-length: 1-byte length descriptor of the R value that follows.
     // * R: arbitrary-length big-endian encoded R value. It must use the
     // shortest possible encoding for a positive integers (which means no null
     // bytes at the start, except a single one when the next byte has its
     // highest bit set).
     // * S-length: 1-byte length descriptor of the S value that follows.
     // * S: arbitrary-length big-endian encoded S value. The same rules apply.
 
     // Minimum and maximum size constraints.
     if (sig.size() < 8 || sig.size() > 72) {
         return false;
     }
 
     //
     // Check that the signature is a compound structure of proper size.
     //
 
     // A signature is of type 0x30 (compound).
     if (sig[0] != 0x30) {
         return false;
     }
 
     // Make sure the length covers the entire signature.
     // Remove:
     // * 1 byte for the coupound type.
     // * 1 byte for the length of the signature.
     if (sig[1] != sig.size() - 2) {
         return false;
     }
 
     //
     // Check that R is an positive integer of sensible size.
     //
 
     // Check whether the R element is an integer.
     if (sig[2] != 0x02) {
         return false;
     }
 
     // Extract the length of the R element.
     const uint32_t lenR = sig[3];
 
     // Zero-length integers are not allowed for R.
     if (lenR == 0) {
         return false;
     }
 
     // Negative numbers are not allowed for R.
     if (sig[4] & 0x80) {
         return false;
     }
 
     // Make sure the length of the R element is consistent with the signature
     // size.
     // Remove:
     // * 1 byte for the coumpound type.
     // * 1 byte for the length of the signature.
     // * 2 bytes for the integer type of R and S.
     // * 2 bytes for the size of R and S.
     // * 1 byte for S itself.
     if (lenR > (sig.size() - 7)) {
         return false;
     }
 
     // Null bytes at the start of R are not allowed, unless R would otherwise be
     // interpreted as a negative number.
     //
     // /!\ This check can only be performed after we checked that lenR is
     //     consistent with the size of the signature or we risk to access out of
     //     bound elements.
     if (lenR > 1 && (sig[4] == 0x00) && !(sig[5] & 0x80)) {
         return false;
     }
 
     //
     // Check that S is an positive integer of sensible size.
     //
 
     // S's definition starts after R's definition:
     // * 1 byte for the coumpound type.
     // * 1 byte for the length of the signature.
     // * 1 byte for the size of R.
     // * lenR bytes for R itself.
     // * 1 byte to get to S.
     const uint32_t startS = lenR + 4;
 
     // Check whether the S element is an integer.
     if (sig[startS] != 0x02) {
         return false;
     }
 
     // Extract the length of the S element.
     const uint32_t lenS = sig[startS + 1];
 
     // Zero-length integers are not allowed for S.
     if (lenS == 0) {
         return false;
     }
 
     // Negative numbers are not allowed for S.
     if (sig[startS + 2] & 0x80) {
         return false;
     }
 
     // Verify that the length of S is consistent with the size of the signature
     // including metadatas:
     // * 1 byte for the integer type of S.
     // * 1 byte for the size of S.
     if (size_t(startS + lenS + 2) != sig.size()) {
         return false;
     }
 
     // Null bytes at the start of S are not allowed, unless S would otherwise be
     // interpreted as a negative number.
     //
     // /!\ This check can only be performed after we checked that lenR and lenS
     //     are consistent with the size of the signature or we risk to access
     //     out of bound elements.
     if (lenS > 1 && (sig[startS + 2] == 0x00) && !(sig[startS + 3] & 0x80)) {
         return false;
     }
 
     return true;
 }
 
 static bool IsSchnorrSig(const slicedvaltype &sig) {
     return sig.size() == 64;
 }
 
 static bool CheckRawECDSASignatureEncoding(const slicedvaltype &sig,
                                            uint32_t flags,
                                            ScriptError *serror) {
     if (IsSchnorrSig(sig)) {
         // In an ECDSA-only context, 64-byte signatures are forbidden.
         return set_error(serror, ScriptError::SIG_BADLENGTH);
     }
     // https://bitcoin.stackexchange.com/a/12556:
     if ((flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S |
                   SCRIPT_VERIFY_STRICTENC)) &&
         !IsValidDERSignatureEncoding(sig)) {
         return set_error(serror, ScriptError::SIG_DER);
     }
     // If the S value is above the order of the curve divided by two, its
     // complement modulo the order could have been used instead, which is
     // one byte shorter when encoded correctly.
     if ((flags & SCRIPT_VERIFY_LOW_S) && !CPubKey::CheckLowS(sig)) {
         return set_error(serror, ScriptError::SIG_HIGH_S);
     }
 
     return true;
 }
 
 static bool CheckRawSchnorrSignatureEncoding(const slicedvaltype &sig,
                                              uint32_t flags,
                                              ScriptError *serror) {
     if (IsSchnorrSig(sig)) {
         return true;
     }
     return set_error(serror, ScriptError::SIG_NONSCHNORR);
 }
 
 static bool CheckRawSignatureEncoding(const slicedvaltype &sig, uint32_t flags,
                                       ScriptError *serror) {
     if (IsSchnorrSig(sig)) {
         // In a generic-signature context, 64-byte signatures are interpreted
         // as Schnorr signatures (always correctly encoded).
         return true;
     }
     return CheckRawECDSASignatureEncoding(sig, flags, serror);
 }
 
 bool CheckDataSignatureEncoding(const valtype &vchSig, uint32_t flags,
                                 ScriptError *serror) {
     // Empty signature. Not strictly DER encoded, but allowed to provide a
     // compact way to provide an invalid signature for use with CHECK(MULTI)SIG
     if (vchSig.size() == 0) {
         return true;
     }
 
     return CheckRawSignatureEncoding(
         vchSig | boost::adaptors::sliced(0, vchSig.size()), flags, serror);
 }
 
 static bool CheckSighashEncoding(const valtype &vchSig, uint32_t flags,
                                  ScriptError *serror) {
     if (flags & SCRIPT_VERIFY_STRICTENC) {
         if (!GetHashType(vchSig).isDefined()) {
             return set_error(serror, ScriptError::SIG_HASHTYPE);
         }
 
         bool usesForkId = GetHashType(vchSig).hasForkId();
         bool forkIdEnabled = flags & SCRIPT_ENABLE_SIGHASH_FORKID;
         if (!forkIdEnabled && usesForkId) {
             return set_error(serror, ScriptError::ILLEGAL_FORKID);
         }
 
         if (forkIdEnabled && !usesForkId) {
             return set_error(serror, ScriptError::MUST_USE_FORKID);
         }
     }
 
     return true;
 }
 
 template <typename F>
 static bool CheckTransactionSignatureEncodingImpl(const valtype &vchSig,
                                                   uint32_t flags,
                                                   ScriptError *serror, F fun) {
     // Empty signature. Not strictly DER encoded, but allowed to provide a
     // compact way to provide an invalid signature for use with CHECK(MULTI)SIG
     if (vchSig.size() == 0) {
         return true;
     }
 
     if (!fun(vchSig | boost::adaptors::sliced(0, vchSig.size() - 1), flags,
              serror)) {
         // serror is set
         return false;
     }
 
     return CheckSighashEncoding(vchSig, flags, serror);
 }
 
 bool CheckTransactionSignatureEncoding(const valtype &vchSig, uint32_t flags,
                                        ScriptError *serror) {
     return CheckTransactionSignatureEncodingImpl(
         vchSig, flags, serror,
         [](const slicedvaltype &templateSig, uint32_t templateFlags,
            ScriptError *templateSerror) {
             return CheckRawSignatureEncoding(templateSig, templateFlags,
                                              templateSerror);
         });
 }
 
 bool CheckTransactionECDSASignatureEncoding(const valtype &vchSig,
                                             uint32_t flags,
                                             ScriptError *serror) {
     return CheckTransactionSignatureEncodingImpl(
         vchSig, flags, serror,
         [](const slicedvaltype &templateSig, uint32_t templateFlags,
            ScriptError *templateSerror) {
             return CheckRawECDSASignatureEncoding(templateSig, templateFlags,
                                                   templateSerror);
         });
 }
 
 bool CheckTransactionSchnorrSignatureEncoding(const valtype &vchSig,
                                               uint32_t flags,
                                               ScriptError *serror) {
     return CheckTransactionSignatureEncodingImpl(
         vchSig, flags, serror,
         [](const slicedvaltype &templateSig, uint32_t templateFlags,
            ScriptError *templateSerror) {
             return CheckRawSchnorrSignatureEncoding(templateSig, templateFlags,
                                                     templateSerror);
         });
 }
 
 static bool IsCompressedOrUncompressedPubKey(const valtype &vchPubKey) {
     switch (vchPubKey.size()) {
-        case 33:
+        case CPubKey::COMPRESSED_PUBLIC_KEY_SIZE:
             // Compressed public key: must start with 0x02 or 0x03.
             return vchPubKey[0] == 0x02 || vchPubKey[0] == 0x03;
 
-        case 65:
+        case CPubKey::PUBLIC_KEY_SIZE:
             // Non-compressed public key: must start with 0x04.
             return vchPubKey[0] == 0x04;
 
         default:
             // Non-canonical public key: invalid size.
             return false;
     }
 }
 
 static bool IsCompressedPubKey(const valtype &vchPubKey) {
-    if (vchPubKey.size() != 33) {
+    if (vchPubKey.size() != CPubKey::COMPRESSED_PUBLIC_KEY_SIZE) {
         // Non-canonical public key: invalid length for compressed key
         return false;
     }
     if (vchPubKey[0] != 0x02 && vchPubKey[0] != 0x03) {
         // Non-canonical public key: invalid prefix for compressed key
         return false;
     }
     return true;
 }
 
 bool CheckPubKeyEncoding(const valtype &vchPubKey, uint32_t flags,
                          ScriptError *serror) {
     if ((flags & SCRIPT_VERIFY_STRICTENC) &&
         !IsCompressedOrUncompressedPubKey(vchPubKey)) {
         return set_error(serror, ScriptError::PUBKEYTYPE);
     }
     // Only compressed keys are accepted when
     // SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE is enabled.
     if ((flags & SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) &&
         !IsCompressedPubKey(vchPubKey)) {
         return set_error(serror, ScriptError::NONCOMPRESSED_PUBKEY);
     }
     return true;
 }
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 0a2380259..cb66b439a 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -1,285 +1,285 @@
 // 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.
 
 #include <script/standard.h>
 
 #include <pubkey.h>
 #include <script/script.h>
 #include <util.h>
 #include <utilstrencodings.h>
 
 typedef std::vector<uint8_t> valtype;
 
 bool fAcceptDatacarrier = DEFAULT_ACCEPT_DATACARRIER;
 
 CScriptID::CScriptID(const CScript &in)
     : uint160(Hash160(in.begin(), in.end())) {}
 
 const char *GetTxnOutputType(txnouttype t) {
     switch (t) {
         case TX_NONSTANDARD:
             return "nonstandard";
         case TX_PUBKEY:
             return "pubkey";
         case TX_PUBKEYHASH:
             return "pubkeyhash";
         case TX_SCRIPTHASH:
             return "scripthash";
         case TX_MULTISIG:
             return "multisig";
         case TX_NULL_DATA:
             return "nulldata";
     }
     return nullptr;
 }
 
 bool Solver(const CScript &scriptPubKey, txnouttype &typeRet,
             std::vector<std::vector<uint8_t>> &vSolutionsRet) {
     // Templates
     static std::multimap<txnouttype, CScript> mTemplates;
     if (mTemplates.empty()) {
         // Standard tx, sender provides pubkey, receiver adds signature
         mTemplates.insert(
             std::make_pair(TX_PUBKEY, CScript() << OP_PUBKEY << OP_CHECKSIG));
 
         // Bitcoin address tx, sender provides hash of pubkey, receiver provides
         // signature and pubkey
         mTemplates.insert(std::make_pair(
             TX_PUBKEYHASH, CScript() << OP_DUP << OP_HASH160 << OP_PUBKEYHASH
                                      << OP_EQUALVERIFY << OP_CHECKSIG));
 
         // Sender provides N pubkeys, receivers provides M signatures
         mTemplates.insert(std::make_pair(
             TX_MULTISIG, CScript() << OP_SMALLINTEGER << OP_PUBKEYS
                                    << OP_SMALLINTEGER << OP_CHECKMULTISIG));
     }
 
     vSolutionsRet.clear();
 
     // Shortcut for pay-to-script-hash, which are more constrained than the
     // other types:
     // it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
     if (scriptPubKey.IsPayToScriptHash()) {
         typeRet = TX_SCRIPTHASH;
         std::vector<uint8_t> hashBytes(scriptPubKey.begin() + 2,
                                        scriptPubKey.begin() + 22);
         vSolutionsRet.push_back(hashBytes);
         return true;
     }
 
     // Provably prunable, data-carrying output
     //
     // So long as script passes the IsUnspendable() test and all but the first
     // byte passes the IsPushOnly() test we don't care what exactly is in the
     // script.
     if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN &&
         scriptPubKey.IsPushOnly(scriptPubKey.begin() + 1)) {
         typeRet = TX_NULL_DATA;
         return true;
     }
 
     // Scan templates
     const CScript &script1 = scriptPubKey;
     for (const std::pair<txnouttype, CScript> &tplate : mTemplates) {
         const CScript &script2 = tplate.second;
         vSolutionsRet.clear();
 
         opcodetype opcode1, opcode2;
         std::vector<uint8_t> vch1, vch2;
 
         // Compare
         CScript::const_iterator pc1 = script1.begin();
         CScript::const_iterator pc2 = script2.begin();
         while (true) {
             if (pc1 == script1.end() && pc2 == script2.end()) {
                 // Found a match
                 typeRet = tplate.first;
                 if (typeRet == TX_MULTISIG) {
                     // Additional checks for TX_MULTISIG:
                     uint8_t m = vSolutionsRet.front()[0];
                     uint8_t n = vSolutionsRet.back()[0];
                     if (m < 1 || n < 1 || m > n ||
                         vSolutionsRet.size() - 2 != n) {
                         return false;
                     }
                 }
                 return true;
             }
             if (!script1.GetOp(pc1, opcode1, vch1)) {
                 break;
             }
             if (!script2.GetOp(pc2, opcode2, vch2)) {
                 break;
             }
 
             // Template matching opcodes:
             if (opcode2 == OP_PUBKEYS) {
-                while (vch1.size() >= 33 && vch1.size() <= 65) {
+                while (CPubKey::ValidSize(vch1)) {
                     vSolutionsRet.push_back(vch1);
                     if (!script1.GetOp(pc1, opcode1, vch1)) {
                         break;
                     }
                 }
                 if (!script2.GetOp(pc2, opcode2, vch2)) {
                     break;
                 }
                 // Normal situation is to fall through to other if/else
                 // statements
             }
 
             if (opcode2 == OP_PUBKEY) {
-                if (vch1.size() < 33 || vch1.size() > 65) {
+                if (!CPubKey::ValidSize(vch1)) {
                     break;
                 }
                 vSolutionsRet.push_back(vch1);
             } else if (opcode2 == OP_PUBKEYHASH) {
                 if (vch1.size() != sizeof(uint160)) {
                     break;
                 }
                 vSolutionsRet.push_back(vch1);
             } else if (opcode2 == OP_SMALLINTEGER) {
                 // Single-byte small integer pushed onto vSolutions
                 if (opcode1 == OP_0 || (opcode1 >= OP_1 && opcode1 <= OP_16)) {
                     char n = (char)CScript::DecodeOP_N(opcode1);
                     vSolutionsRet.push_back(valtype(1, n));
                 } else {
                     break;
                 }
             } else if (opcode1 != opcode2 || vch1 != vch2) {
                 // Others must match exactly
                 break;
             }
         }
     }
 
     vSolutionsRet.clear();
     typeRet = TX_NONSTANDARD;
     return false;
 }
 
 bool ExtractDestination(const CScript &scriptPubKey,
                         CTxDestination &addressRet) {
     std::vector<valtype> vSolutions;
     txnouttype whichType;
     if (!Solver(scriptPubKey, whichType, vSolutions)) {
         return false;
     }
 
     if (whichType == TX_PUBKEY) {
         CPubKey pubKey(vSolutions[0]);
         if (!pubKey.IsValid()) {
             return false;
         }
 
         addressRet = pubKey.GetID();
         return true;
     }
     if (whichType == TX_PUBKEYHASH) {
         addressRet = CKeyID(uint160(vSolutions[0]));
         return true;
     }
     if (whichType == TX_SCRIPTHASH) {
         addressRet = CScriptID(uint160(vSolutions[0]));
         return true;
     }
     // Multisig txns have more than one address...
     return false;
 }
 
 bool ExtractDestinations(const CScript &scriptPubKey, txnouttype &typeRet,
                          std::vector<CTxDestination> &addressRet,
                          int &nRequiredRet) {
     addressRet.clear();
     typeRet = TX_NONSTANDARD;
     std::vector<valtype> vSolutions;
     if (!Solver(scriptPubKey, typeRet, vSolutions)) {
         return false;
     }
     if (typeRet == TX_NULL_DATA) {
         // This is data, not addresses
         return false;
     }
 
     if (typeRet == TX_MULTISIG) {
         nRequiredRet = vSolutions.front()[0];
         for (size_t i = 1; i < vSolutions.size() - 1; i++) {
             CPubKey pubKey(vSolutions[i]);
             if (!pubKey.IsValid()) {
                 continue;
             }
 
             CTxDestination address = pubKey.GetID();
             addressRet.push_back(address);
         }
 
         if (addressRet.empty()) {
             return false;
         }
     } else {
         nRequiredRet = 1;
         CTxDestination address;
         if (!ExtractDestination(scriptPubKey, address)) {
             return false;
         }
         addressRet.push_back(address);
     }
 
     return true;
 }
 
 namespace {
 class CScriptVisitor : public boost::static_visitor<bool> {
 private:
     CScript *script;
 
 public:
     explicit CScriptVisitor(CScript *scriptin) { script = scriptin; }
 
     bool operator()(const CNoDestination &dest) const {
         script->clear();
         return false;
     }
 
     bool operator()(const CKeyID &keyID) const {
         script->clear();
         *script << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY
                 << OP_CHECKSIG;
         return true;
     }
 
     bool operator()(const CScriptID &scriptID) const {
         script->clear();
         *script << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
         return true;
     }
 };
 } // namespace
 
 CScript GetScriptForDestination(const CTxDestination &dest) {
     CScript script;
 
     boost::apply_visitor(CScriptVisitor(&script), dest);
     return script;
 }
 
 CScript GetScriptForRawPubKey(const CPubKey &pubKey) {
     return CScript() << std::vector<uint8_t>(pubKey.begin(), pubKey.end())
                      << OP_CHECKSIG;
 }
 
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey> &keys) {
     CScript script;
 
     script << CScript::EncodeOP_N(nRequired);
     for (const CPubKey &key : keys) {
         script << ToByteVector(key);
     }
     script << CScript::EncodeOP_N(keys.size()) << OP_CHECKMULTISIG;
     return script;
 }
 
 bool IsValidDestination(const CTxDestination &dest) {
     return dest.which() != 0;
 }