diff --git a/src/hash.cpp b/src/hash.cpp
index 6a22b583c..966bbe869 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -1,84 +1,83 @@
 // Copyright (c) 2013-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 <hash.h>
 
 #include <crypto/hmac_sha512.h>
 
 inline uint32_t ROTL32(uint32_t x, int8_t r) {
     return (x << r) | (x >> (32 - r));
 }
 
-uint32_t MurmurHash3(uint32_t nHashSeed,
-                     const std::vector<uint8_t> &vDataToHash) {
+uint32_t MurmurHash3(uint32_t nHashSeed, Span<const uint8_t> vDataToHash) {
     // The following is MurmurHash3 (x86_32), see
     // http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
     uint32_t h1 = nHashSeed;
     const uint32_t c1 = 0xcc9e2d51;
     const uint32_t c2 = 0x1b873593;
 
     const int nblocks = vDataToHash.size() / 4;
 
     //----------
     // body
     const uint8_t *blocks = vDataToHash.data();
 
     for (int i = 0; i < nblocks; ++i) {
         uint32_t k1 = ReadLE32(blocks + i * 4);
 
         k1 *= c1;
         k1 = ROTL32(k1, 15);
         k1 *= c2;
 
         h1 ^= k1;
         h1 = ROTL32(h1, 13);
         h1 = h1 * 5 + 0xe6546b64;
     }
 
     //----------
     // tail
     const uint8_t *tail = vDataToHash.data() + nblocks * 4;
 
     uint32_t k1 = 0;
 
     switch (vDataToHash.size() & 3) {
         case 3:
             k1 ^= tail[2] << 16;
         // FALLTHROUGH
         case 2:
             k1 ^= tail[1] << 8;
         // FALLTHROUGH
         case 1:
             k1 ^= tail[0];
             k1 *= c1;
             k1 = ROTL32(k1, 15);
             k1 *= c2;
             h1 ^= k1;
     }
 
     //----------
     // finalization
     h1 ^= vDataToHash.size();
     h1 ^= h1 >> 16;
     h1 *= 0x85ebca6b;
     h1 ^= h1 >> 13;
     h1 *= 0xc2b2ae35;
     h1 ^= h1 >> 16;
 
     return h1;
 }
 
 void BIP32Hash(const ChainCode &chainCode, uint32_t nChild, uint8_t header,
                const uint8_t data[32], uint8_t output[64]) {
     uint8_t num[4];
     num[0] = (nChild >> 24) & 0xFF;
     num[1] = (nChild >> 16) & 0xFF;
     num[2] = (nChild >> 8) & 0xFF;
     num[3] = (nChild >> 0) & 0xFF;
     CHMAC_SHA512(chainCode.begin(), chainCode.size())
         .Write(&header, 1)
         .Write(data, 32)
         .Write(num, 4)
         .Finalize(output);
 }
diff --git a/src/hash.h b/src/hash.h
index 73ddff181..e2ba23156 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -1,209 +1,208 @@
 // 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_HASH_H
 #define BITCOIN_HASH_H
 
 #include <crypto/common.h>
 #include <crypto/ripemd160.h>
 #include <crypto/sha256.h>
 #include <prevector.h>
 #include <serialize.h>
 #include <uint256.h>
 #include <version.h>
 
 #include <vector>
 
 typedef uint256 ChainCode;
 
 /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
 class CHash256 {
 private:
     CSHA256 sha;
 
 public:
     static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
 
     void Finalize(uint8_t hash[OUTPUT_SIZE]) {
         uint8_t buf[CSHA256::OUTPUT_SIZE];
         sha.Finalize(buf);
         sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
     }
 
     CHash256 &Write(Span<const uint8_t> input) {
         sha.Write(input.data(), input.size());
         return *this;
     }
 
     CHash256 &Reset() {
         sha.Reset();
         return *this;
     }
 };
 
 /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
 class CHash160 {
 private:
     CSHA256 sha;
 
 public:
     static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
 
     void Finalize(uint8_t hash[OUTPUT_SIZE]) {
         uint8_t buf[CSHA256::OUTPUT_SIZE];
         sha.Finalize(buf);
         CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
     }
 
     CHash160 &Write(Span<const uint8_t> input) {
         sha.Write(input.data(), input.size());
         return *this;
     }
 
     CHash160 &Reset() {
         sha.Reset();
         return *this;
     }
 };
 
 /** Compute the 256-bit hash of an object. */
 template <typename T1> inline uint256 Hash(const T1 pbegin, const T1 pend) {
     static const uint8_t pblank[1] = {};
     uint256 result;
     CHash256()
         .Write({pbegin == pend ? pblank : (const uint8_t *)&pbegin[0],
                 (pend - pbegin) * sizeof(pbegin[0])})
         .Finalize((uint8_t *)&result);
     return result;
 }
 
 /** Compute the 256-bit hash of the concatenation of two objects. */
 template <typename T1, typename T2>
 inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin,
                     const T2 p2end) {
     static const uint8_t pblank[1] = {};
     uint256 result;
     CHash256()
         .Write({p1begin == p1end ? pblank : (const uint8_t *)&p1begin[0],
                 (p1end - p1begin) * sizeof(p1begin[0])})
         .Write({p2begin == p2end ? pblank : (const uint8_t *)&p2begin[0],
                 (p2end - p2begin) * sizeof(p2begin[0])})
         .Finalize((uint8_t *)&result);
     return result;
 }
 
 /** Compute the 160-bit hash an object. */
 template <typename T1> inline uint160 Hash160(const T1 pbegin, const T1 pend) {
     static uint8_t pblank[1] = {};
     uint160 result;
     CHash160()
         .Write({pbegin == pend ? pblank : (const uint8_t *)&pbegin[0],
                 (pend - pbegin) * sizeof(pbegin[0])})
         .Finalize((uint8_t *)&result);
     return result;
 }
 
 /** Compute the 160-bit hash of a vector. */
 inline uint160 Hash160(const std::vector<uint8_t> &vch) {
     return Hash160(vch.begin(), vch.end());
 }
 
 /** Compute the 160-bit hash of a vector. */
 template <unsigned int N>
 inline uint160 Hash160(const prevector<N, uint8_t> &vch) {
     return Hash160(vch.begin(), vch.end());
 }
 
 /** A writer stream (for serialization) that computes a 256-bit hash. */
 class CHashWriter {
 private:
     CHash256 ctx;
 
     const int nType;
     const int nVersion;
 
 public:
     CHashWriter(int nTypeIn, int nVersionIn)
         : nType(nTypeIn), nVersion(nVersionIn) {}
 
     int GetType() const { return nType; }
     int GetVersion() const { return nVersion; }
 
     void write(const char *pch, size_t size) {
         ctx.Write({(const uint8_t *)pch, size});
     }
 
     // invalidates the object
     uint256 GetHash() {
         uint256 result;
         ctx.Finalize((uint8_t *)&result);
         return result;
     }
 
     /**
      * Returns the first 64 bits from the resulting hash.
      */
     inline uint64_t GetCheapHash() {
         uint8_t result[CHash256::OUTPUT_SIZE];
         ctx.Finalize(result);
         return ReadLE64(result);
     }
 
     template <typename T> CHashWriter &operator<<(const T &obj) {
         // Serialize to this stream
         ::Serialize(*this, obj);
         return (*this);
     }
 };
 
 /**
  * Reads data from an underlying stream, while hashing the read data.
  */
 template <typename Source> class CHashVerifier : public CHashWriter {
 private:
     Source *source;
 
 public:
     explicit CHashVerifier(Source *source_)
         : CHashWriter(source_->GetType(), source_->GetVersion()),
           source(source_) {}
 
     void read(char *pch, size_t nSize) {
         source->read(pch, nSize);
         this->write(pch, nSize);
     }
 
     void ignore(size_t nSize) {
         char data[1024];
         while (nSize > 0) {
             size_t now = std::min<size_t>(nSize, 1024);
             read(data, now);
             nSize -= now;
         }
     }
 
     template <typename T> CHashVerifier<Source> &operator>>(T &&obj) {
         // Unserialize from this stream
         ::Unserialize(*this, obj);
         return (*this);
     }
 };
 
 /** Compute the 256-bit hash of an object's serialization. */
 template <typename T>
 uint256 SerializeHash(const T &obj, int nType = SER_GETHASH,
                       int nVersion = PROTOCOL_VERSION) {
     CHashWriter ss(nType, nVersion);
     ss << obj;
     return ss.GetHash();
 }
 
-uint32_t MurmurHash3(uint32_t nHashSeed,
-                     const std::vector<uint8_t> &vDataToHash);
+uint32_t MurmurHash3(uint32_t nHashSeed, Span<const uint8_t> vDataToHash);
 
 void BIP32Hash(const ChainCode &chainCode, uint32_t nChild, uint8_t header,
                const uint8_t data[32], uint8_t output[64]);
 
 #endif // BITCOIN_HASH_H