diff --git a/COPYING b/COPYING
index 1fb429f..fec0301 100644
--- a/COPYING
+++ b/COPYING
@@ -1,3 +1,6 @@
+With the exception of bitcoin/rpc.py, which is licensed under the GNU LGPL, the
+following license terms apply to the package python-bitcoinlib unless otherwise
+noted:
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README b/README
index 063fc4b..72c990e 100644
--- a/README
+++ b/README
@@ -1,9 +1,5 @@
+Peter Todd has taken over maintainership of python-bitcoinlib. Please use the
+new repository at:
 
-This python library provides an easy interface to the bitcoin
-data structures and protocol.
+https://github.com/petertodd/python-bitcoinlib
 
-
-Unit tests
-----------
-
-python -m unittest discover
diff --git a/bitcoin/__init__.py b/bitcoin/__init__.py
index e69de29..27fe8df 100644
--- a/bitcoin/__init__.py
+++ b/bitcoin/__init__.py
@@ -0,0 +1,4 @@
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from __future__ import absolute_import, division, print_function, unicode_literals
diff --git a/bitcoin/base58.py b/bitcoin/base58.py
index 20d5a75..855f8bf 100644
--- a/bitcoin/base58.py
+++ b/bitcoin/base58.py
@@ -8,6 +8,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
 from bitcoin.serialize import Hash, ser_uint256
 
 b58_digits = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
@@ -24,7 +26,7 @@ def encode(b):
     """Encode bytes to a base58-encoded string"""
 
     # Convert big-endian bytes to integer
-    n = int('0x0' + hexlify(b), 16)
+    n = int('0x0' + hexlify(b).decode('utf8'), 16)
 
     # Divide that integer into bas58
     res = []
@@ -34,9 +36,14 @@ def encode(b):
     res = ''.join(res[::-1])
 
     # Encode leading zeros as base58 zeros
+    import sys
+    czero = b'\x00'
+    if sys.version > '3':
+        # In Python3 indexing a bytes returns numbers, not characters.
+        czero = 0
     pad = 0
     for c in b:
-        if c == chr(0): pad += 1
+        if c == czero: pad += 1
         else: break
     return b58_digits[0] * pad + res
 
@@ -58,7 +65,7 @@ def decode(s):
     h = '%x' % n
     if len(h) % 2:
         h = '0' + h
-    res = unhexlify(h)
+    res = unhexlify(h.encode('utf8'))
 
     # Add padding back.
     pad = 0
@@ -77,6 +84,9 @@ def __new__(cls, data, nVersion):
         self.nVersion = nVersion
         return self
 
+    def __repr__(self):
+        return '%s(%s, %d)' % (self.__class__.__name__, bytes.__repr__(self), self.nVersion)
+
     def __str__(self):
         vs = chr(self.nVersion) + self
         check = ser_uint256(Hash(vs))[0:4]
diff --git a/bitcoin/bignum.py b/bitcoin/bignum.py
index ed62d15..2dbe662 100644
--- a/bitcoin/bignum.py
+++ b/bitcoin/bignum.py
@@ -6,6 +6,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
 import struct
 
 
@@ -15,7 +17,7 @@ def bn_bytes(v, have_ext=False):
     ext = 0
     if have_ext:
         ext = 1
-    return ((v.bit_length()+7)/8) + ext
+    return ((v.bit_length()+7)//8) + ext
 
 def bn2bin(v):
     s = bytearray()
@@ -26,7 +28,7 @@ def bn2bin(v):
     return s
 
 def bin2bn(s):
-    l = 0L
+    l = 0
     for ch in s:
         l = (l << 8) | ch
     return l
@@ -41,7 +43,7 @@ def bn2mpi(v):
         neg = True
         v = -v
 
-    s = struct.pack(">I", bn_bytes(v, have_ext))
+    s = struct.pack(b">I", bn_bytes(v, have_ext))
     ext = bytearray()
     if have_ext:
         ext.append(0)
@@ -57,11 +59,11 @@ def mpi2bn(s):
     if len(s) < 4:
         return None
     s_size = str(s[:4])
-    v_len = struct.unpack(">I", s_size)[0]
+    v_len = struct.unpack(b">I", s_size)[0]
     if len(s) != (v_len + 4):
         return None
     if v_len == 0:
-        return 0L
+        return 0
 
     v_str = bytearray(s[4:])
     neg = False
@@ -87,7 +89,7 @@ def bn2vch(v):
     return str(mpi2vch(bn2mpi(v)))
 
 def vch2mpi(s):
-    r = struct.pack(">I", len(s))   # size
+    r = struct.pack(b">I", len(s))   # size
     r += s[::-1]            # reverse string, converting LE->BE
     return r
 
diff --git a/bitcoin/bloom.py b/bitcoin/bloom.py
new file mode 100644
index 0000000..c562d08
--- /dev/null
+++ b/bitcoin/bloom.py
@@ -0,0 +1,105 @@
+
+#
+# bloom.py
+#
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import struct
+import math
+from bitcoin.serialize import *
+from bitcoin.coredefs import *
+from bitcoin.core import *
+from bitcoin.hash import MurmurHash3
+
+class CBloomFilter(object):
+    # 20,000 items with fp rate < 0.1% or 10,000 items and <0.0001%
+    MAX_BLOOM_FILTER_SIZE = 36000
+    MAX_HASH_FUNCS = 50
+
+    UPDATE_NONE = 0
+    UPDATE_ALL = 1
+    UPDATE_P2PUBKEY_ONLY = 2
+    UPDATE_MASK = 3
+
+    def __init__(self, nElements, nFPRate, nTweak, nFlags):
+        """Create a new bloom filter
+
+        The filter will have a given false-positive rate when filled with the
+        given number of elements.
+
+        Note that if the given parameters will result in a filter outside the
+        bounds of the protocol limits, the filter created will be as close to
+        the given parameters as possible within the protocol limits. This will
+        apply if nFPRate is very low or nElements is unreasonably high.
+
+        nTweak is a constant which is added to the seed value passed to the
+        hash function It should generally always be a random value (and is
+        largely only exposed for unit testing)
+
+        nFlags should be one of the UPDATE_* enums (but not _MASK)
+        """
+        LN2SQUARED = 0.4804530139182014246671025263266649717305529515945455
+        LN2 = 0.6931471805599453094172321214581765680755001343602552
+        self.vData = bytearray(int(min(-1  / LN2SQUARED * nElements * math.log(nFPRate), self.MAX_BLOOM_FILTER_SIZE * 8) / 8))
+        self.nHashFuncs = int(min(len(self.vData) * 8 / nElements * LN2, self.MAX_HASH_FUNCS))
+        self.nTweak = nTweak
+        self.nFlags = nFlags
+
+    def bloom_hash(self, nHashNum, vDataToHash):
+        return MurmurHash3(((nHashNum * 0xFBA4C795) + self.nTweak) & 0xFFFFFFFF, vDataToHash) % (len(self.vData) * 8)
+
+    __bit_mask = bytearray([0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80])
+    def insert(self, elem):
+        """Insert an element in the filter.
+
+        elem may be a COutPoint or bytes
+        """
+        if isinstance(elem, COutPoint):
+            elem = elem.serialize()
+
+        if len(self.vData) == 1 and self.vData[0] == 0xff:
+            return
+
+        for i in range(0, self.nHashFuncs):
+            nIndex = self.bloom_hash(i, elem)
+            # Sets bit nIndex of vData
+            self.vData[nIndex >> 3] |= self.__bit_mask[7 & nIndex]
+
+    def contains(self, elem):
+        """Test if the filter contains an element
+
+        elem may be a COutPoint or bytes
+        """
+        if isinstance(elem, COutPoint):
+            elem = elem.serialize()
+
+        if len(self.vData) == 1 and self.vData[0] == 0xff:
+            return True
+
+        for i in range(0, self.nHashFuncs):
+            nIndex = self.bloom_hash(i, elem)
+            if not (self.vData[nIndex >> 3] & self.__bit_mask[7 & nIndex]):
+                return False
+        return True
+
+    def IsWithinSizeConstraints(self):
+        return len(self.vData) <= self.MAX_BLOOM_FILTER_SIZE and self.nHashFuncs <= self.MAX_HASH_FUNCS
+
+    def IsRelevantAndUpdate(tx, tx_hash):
+        # Not useful for a client, so not implemented yet.
+        raise NotImplementedError
+
+    __struct = struct.Struct(b'<IIB')
+    def deserialize(self, f):
+        self.vData = deser_string(f)
+        (self.nHashFuncs,
+         self.nTweak,
+         self.nFlags) = self.__struct.unpack(f.read(self.__struct.size))
+
+    def serialize(self):
+        r = ser_string(self.vData)
+        return r + self.__struct.pack(self.nHashFuncs, self.nTweak, self.nFlags)
diff --git a/bitcoin/core.py b/bitcoin/core.py
index 230b5ae..1d247a7 100644
--- a/bitcoin/core.py
+++ b/bitcoin/core.py
@@ -6,6 +6,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
 import struct
 import socket
 import binascii
@@ -20,24 +22,24 @@ def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.nTime = 0
         self.nServices = 1
-        self.pchReserved = "\x00" * 10 + "\xff" * 2
+        self.pchReserved = b"\x00" * 10 + b"\xff" * 2
         self.ip = "0.0.0.0"
         self.port = 0
     def deserialize(self, f):
         if self.protover >= CADDR_TIME_VERSION:
-            self.nTime = struct.unpack("<I", f.read(4))[0]
-        self.nServices = struct.unpack("<Q", f.read(8))[0]
+            self.nTime = struct.unpack(b"<I", f.read(4))[0]
+        self.nServices = struct.unpack(b"<Q", f.read(8))[0]
         self.pchReserved = f.read(12)
         self.ip = socket.inet_ntoa(f.read(4))
-        self.port = struct.unpack(">H", f.read(2))[0]
+        self.port = struct.unpack(b">H", f.read(2))[0]
     def serialize(self):
-        r = ""
+        r = b""
         if self.protover >= CADDR_TIME_VERSION:
-            r += struct.pack("<I", self.nTime)
-        r += struct.pack("<Q", self.nServices)
+            r += struct.pack(b"<I", self.nTime)
+        r += struct.pack(b"<Q", self.nServices)
         r += self.pchReserved
         r += socket.inet_aton(self.ip)
-        r += struct.pack(">H", self.port)
+        r += struct.pack(b">H", self.port)
         return r
     def __repr__(self):
         return "CAddress(nTime=%d nServices=%i ip=%s port=%i)" % (self.nTime, self.nServices, self.ip, self.port)
@@ -49,13 +51,13 @@ class CInv(object):
         2: "Block"}
     def __init__(self):
         self.type = 0
-        self.hash = 0L
+        self.hash = 0
     def deserialize(self, f):
-        self.type = struct.unpack("<i", f.read(4))[0]
+        self.type = struct.unpack(b"<i", f.read(4))[0]
         self.hash = deser_uint256(f)
     def serialize(self):
-        r = ""
-        r += struct.pack("<i", self.type)
+        r = b""
+        r += struct.pack(b"<i", self.type)
         r += ser_uint256(self.hash)
         return r
     def __repr__(self):
@@ -66,11 +68,11 @@ def __init__(self):
         self.nVersion = PROTO_VERSION
         self.vHave = []
     def deserialize(self, f):
-        self.nVersion = struct.unpack("<i", f.read(4))[0]
+        self.nVersion = struct.unpack(b"<i", f.read(4))[0]
         self.vHave = deser_uint256_vector(f)
     def serialize(self):
-        r = ""
-        r += struct.pack("<i", self.nVersion)
+        r = b""
+        r += struct.pack(b"<i", self.nVersion)
         r += ser_uint256_vector(self.vHave)
         return r
     def __repr__(self):
@@ -82,11 +84,11 @@ def __init__(self):
         self.n = 0
     def deserialize(self, f):
         self.hash = deser_uint256(f)
-        self.n = struct.unpack("<I", f.read(4))[0]
+        self.n = struct.unpack(b"<I", f.read(4))[0]
     def serialize(self):
-        r = ""
+        r = b""
         r += ser_uint256(self.hash)
-        r += struct.pack("<I", self.n)
+        r += struct.pack(b"<I", self.n)
         return r
     def set_null(self):
         self.hash = 0
@@ -102,18 +104,18 @@ def __repr__(self):
 class CTxIn(object):
     def __init__(self):
         self.prevout = COutPoint()
-        self.scriptSig = ""
+        self.scriptSig = b""
         self.nSequence = 0xffffffff
     def deserialize(self, f):
         self.prevout = COutPoint()
         self.prevout.deserialize(f)
         self.scriptSig = deser_string(f)
-        self.nSequence = struct.unpack("<I", f.read(4))[0]
+        self.nSequence = struct.unpack(b"<I", f.read(4))[0]
     def serialize(self):
-        r = ""
+        r = b""
         r += self.prevout.serialize()
         r += ser_string(self.scriptSig)
-        r += struct.pack("<I", self.nSequence)
+        r += struct.pack(b"<I", self.nSequence)
         return r
     def is_final(self):
         return (self.nSequence == 0xffffffff)
@@ -133,13 +135,13 @@ def __repr__(self):
 class CTxOut(object):
     def __init__(self):
         self.nValue = -1
-        self.scriptPubKey = ""
+        self.scriptPubKey = b""
     def deserialize(self, f):
-        self.nValue = struct.unpack("<q", f.read(8))[0]
+        self.nValue = struct.unpack(b"<q", f.read(8))[0]
         self.scriptPubKey = deser_string(f)
     def serialize(self):
-        r = ""
-        r += struct.pack("<q", self.nValue)
+        r = b""
+        r += struct.pack(b"<q", self.nValue)
         r += ser_string(self.scriptPubKey)
         return r
     def is_valid(self):
@@ -170,16 +172,16 @@ def __init__(self):
         self.dPriority = None
         self.ser_size = 0
     def deserialize(self, f):
-        self.nVersion = struct.unpack("<i", f.read(4))[0]
+        self.nVersion = struct.unpack(b"<i", f.read(4))[0]
         self.vin = deser_vector(f, CTxIn)
         self.vout = deser_vector(f, CTxOut)
-        self.nLockTime = struct.unpack("<I", f.read(4))[0]
+        self.nLockTime = struct.unpack(b"<I", f.read(4))[0]
     def serialize(self):
-        r = ""
-        r += struct.pack("<i", self.nVersion)
+        r = b""
+        r += struct.pack(b"<i", self.nVersion)
         r += ser_vector(self.vin)
         r += ser_vector(self.vout)
-        r += struct.pack("<I", self.nLockTime)
+        r += struct.pack(b"<I", self.nLockTime)
         return r
     def calc_sha256(self):
         if self.sha256 is None:
@@ -233,21 +235,21 @@ def __init__(self):
         self.vtx = []
         self.sha256 = None
     def deserialize(self, f):
-        self.nVersion = struct.unpack("<i", f.read(4))[0]
+        self.nVersion = struct.unpack(b"<i", f.read(4))[0]
         self.hashPrevBlock = deser_uint256(f)
         self.hashMerkleRoot = deser_uint256(f)
-        self.nTime = struct.unpack("<I", f.read(4))[0]
-        self.nBits = struct.unpack("<I", f.read(4))[0]
-        self.nNonce = struct.unpack("<I", f.read(4))[0]
+        self.nTime = struct.unpack(b"<I", f.read(4))[0]
+        self.nBits = struct.unpack(b"<I", f.read(4))[0]
+        self.nNonce = struct.unpack(b"<I", f.read(4))[0]
         self.vtx = deser_vector(f, CTransaction)
     def serialize_hdr(self):
-        r = ""
-        r += struct.pack("<i", self.nVersion)
+        r = b""
+        r += struct.pack(b"<i", self.nVersion)
         r += ser_uint256(self.hashPrevBlock)
         r += ser_uint256(self.hashMerkleRoot)
-        r += struct.pack("<I", self.nTime)
-        r += struct.pack("<I", self.nBits)
-        r += struct.pack("<I", self.nNonce)
+        r += struct.pack(b"<I", self.nTime)
+        r += struct.pack(b"<I", self.nBits)
+        r += struct.pack(b"<I", self.nNonce)
         return r
     def serialize(self):
         r = self.serialize_hdr()
@@ -265,7 +267,7 @@ def calc_merkle(self):
             hashes.append(ser_uint256(tx.sha256))
         while len(hashes) > 1:
             newhashes = []
-            for i in xrange(0, len(hashes), 2):
+            for i in range(0, len(hashes), 2):
                 i2 = min(i+1, len(hashes)-1)
                 newhashes.append(hashlib.sha256(hashlib.sha256(hashes[i] + hashes[i2]).digest()).digest())
             hashes = newhashes
@@ -293,35 +295,35 @@ def __init__(self):
         self.nMaxVer = 0
         self.setSubVer = []
         self.nPriority = 0
-        self.strComment = ""
-        self.strStatusBar = ""
-        self.strReserved = ""
+        self.strComment = b""
+        self.strStatusBar = b""
+        self.strReserved = b""
     def deserialize(self, f):
-        self.nVersion = struct.unpack("<i", f.read(4))[0]
-        self.nRelayUntil = struct.unpack("<q", f.read(8))[0]
-        self.nExpiration = struct.unpack("<q", f.read(8))[0]
-        self.nID = struct.unpack("<i", f.read(4))[0]
-        self.nCancel = struct.unpack("<i", f.read(4))[0]
+        self.nVersion = struct.unpack(b"<i", f.read(4))[0]
+        self.nRelayUntil = struct.unpack(b"<q", f.read(8))[0]
+        self.nExpiration = struct.unpack(b"<q", f.read(8))[0]
+        self.nID = struct.unpack(b"<i", f.read(4))[0]
+        self.nCancel = struct.unpack(b"<i", f.read(4))[0]
         self.setCancel = deser_int_vector(f)
-        self.nMinVer = struct.unpack("<i", f.read(4))[0]
-        self.nMaxVer = struct.unpack("<i", f.read(4))[0]
+        self.nMinVer = struct.unpack(b"<i", f.read(4))[0]
+        self.nMaxVer = struct.unpack(b"<i", f.read(4))[0]
         self.setSubVer = deser_string_vector(f)
-        self.nPriority = struct.unpack("<i", f.read(4))[0]
+        self.nPriority = struct.unpack(b"<i", f.read(4))[0]
         self.strComment = deser_string(f)
         self.strStatusBar = deser_string(f)
         self.strReserved = deser_string(f)
     def serialize(self):
-        r = ""
-        r += struct.pack("<i", self.nVersion)
-        r += struct.pack("<q", self.nRelayUntil)
-        r += struct.pack("<q", self.nExpiration)
-        r += struct.pack("<i", self.nID)
-        r += struct.pack("<i", self.nCancel)
+        r = b""
+        r += struct.pack(b"<i", self.nVersion)
+        r += struct.pack(b"<q", self.nRelayUntil)
+        r += struct.pack(b"<q", self.nExpiration)
+        r += struct.pack(b"<i", self.nID)
+        r += struct.pack(b"<i", self.nCancel)
         r += ser_int_vector(self.setCancel)
-        r += struct.pack("<i", self.nMinVer)
-        r += struct.pack("<i", self.nMaxVer)
+        r += struct.pack(b"<i", self.nMinVer)
+        r += struct.pack(b"<i", self.nMaxVer)
         r += ser_string_vector(self.setSubVer)
-        r += struct.pack("<i", self.nPriority)
+        r += struct.pack(b"<i", self.nPriority)
         r += ser_string(self.strComment)
         r += ser_string(self.strStatusBar)
         r += ser_string(self.strReserved)
@@ -331,13 +333,13 @@ def __repr__(self):
 
 class CAlert(object):
     def __init__(self):
-        self.vchMsg = ""
-        self.vchSig = ""
+        self.vchMsg = b""
+        self.vchSig = b""
     def deserialize(self, f):
         self.vchMsg = deser_string(f)
         self.vchSig = deser_string(f)
     def serialize(self):
-        r = ""
+        r = b""
         r += ser_string(self.vchMsg)
         r += ser_string(self.vchSig)
         return r
diff --git a/bitcoin/coredefs.py b/bitcoin/coredefs.py
index e7b3d90..5ecf8eb 100644
--- a/bitcoin/coredefs.py
+++ b/bitcoin/coredefs.py
@@ -6,6 +6,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
 PROTO_VERSION = 60002
 
 CADDR_TIME_VERSION = 31402
@@ -32,29 +34,29 @@ def __init__(self, msg_start, block0, checkpoints):
         self.checkpoints = checkpoints
 
         self.checkpoint_max = 0
-        for height in self.checkpoints.iterkeys():
+        for height in self.checkpoints.keys():
             if height > self.checkpoint_max:
                 self.checkpoint_max = height
 
 NETWORKS = {
- 'mainnet' : NetMagic("\xf9\xbe\xb4\xd9",
-    0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26fL,
+ 'mainnet' : NetMagic(b"\xf9\xbe\xb4\xd9",
+    0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f,
     {
-     0: 0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26fL,
-         11111: 0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1dL,
-         33333: 0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6L,
-         74000: 0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20L,
-        105000: 0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97L,
-        134444: 0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0feL,
-        168000: 0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763L,
-        193000: 0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317L,
-    210000: 0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342eL,
-    216116: 0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4eL,
+     0: 0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f,
+         11111: 0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d,
+         33333: 0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6,
+         74000: 0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20,
+        105000: 0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97,
+        134444: 0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe,
+        168000: 0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763,
+        193000: 0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317,
+    210000: 0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e,
+    216116: 0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e,
     }),
- 'testnet3' : NetMagic("\x0b\x11\x09\x07",
-        0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943L,
+ 'testnet3' : NetMagic(b"\x0b\x11\x09\x07",
+        0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943,
     {
-     0: 0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943L,
+     0: 0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943,
     })
 }
 
diff --git a/bitcoin/hash.py b/bitcoin/hash.py
new file mode 100644
index 0000000..158e61a
--- /dev/null
+++ b/bitcoin/hash.py
@@ -0,0 +1,78 @@
+
+#
+# hash.py
+#
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import struct
+from bitcoin.serialize import *
+from bitcoin.coredefs import *
+from bitcoin.script import CScript
+
+def ROTL32(x, r):
+    assert x <= 0xFFFFFFFF
+    return ((x << r) & 0xFFFFFFFF) | (x >> (32 - r))
+
+def MurmurHash3(nHashSeed, vDataToHash):
+    """MurmurHash3 (x86_32)
+
+    Used for bloom filters. See http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
+    """
+
+    assert nHashSeed <= 0xFFFFFFFF
+
+    h1 = nHashSeed
+    c1 = 0xcc9e2d51
+    c2 = 0x1b873593
+
+    # body
+    i = 0
+    while i < len(vDataToHash) - len(vDataToHash) % 4 \
+          and len(vDataToHash) - i >= 4:
+
+        k1 = struct.unpack(b"<L", vDataToHash[i:i+4])[0]
+
+        k1 = (k1 * c1) & 0xFFFFFFFF
+        k1 = ROTL32(k1, 15)
+        k1 = (k1 * c2) & 0xFFFFFFFF
+
+        h1 ^= k1
+        h1 = ROTL32(h1, 13)
+        h1 = (((h1*5) & 0xFFFFFFFF) + 0xe6546b64) & 0xFFFFFFFF
+
+        i += 4
+
+    # tail
+    k1 = 0
+    j = (len(vDataToHash) // 4) * 4
+    import sys
+    bord = ord
+    if sys.version > '3':
+        # In Py3 indexing bytes returns numbers, not characters
+        bord = lambda x: x
+    if len(vDataToHash) & 3 >= 3:
+        k1 ^= bord(vDataToHash[j+2]) << 16
+    if len(vDataToHash) & 3 >= 2:
+        k1 ^= bord(vDataToHash[j+1]) << 8
+    if len(vDataToHash) & 3 >= 1:
+        k1 ^= bord(vDataToHash[j])
+
+    k1 &= 0xFFFFFFFF
+    k1 = (k1 * c1) & 0xFFFFFFFF
+    k1 = ROTL32(k1, 15)
+    k1 = (k1 * c2) & 0xFFFFFFFF
+    h1 ^= k1
+
+    # finalization
+    h1 ^= len(vDataToHash) & 0xFFFFFFFF
+    h1 ^= (h1 & 0xFFFFFFFF) >> 16
+    h1 *= 0x85ebca6b
+    h1 ^= (h1 & 0xFFFFFFFF) >> 13
+    h1 *= 0xc2b2ae35
+    h1 ^= (h1 & 0xFFFFFFFF) >> 16
+
+    return h1 & 0xFFFFFFFF
diff --git a/bitcoin/key.py b/bitcoin/key.py
index 3b7a3f6..28fc9de 100644
--- a/bitcoin/key.py
+++ b/bitcoin/key.py
@@ -42,6 +42,8 @@ def generate(self, secret=None):
             group = ssl.EC_KEY_get0_group(self.k)
             pub_key = ssl.EC_POINT_new(group)
             ctx = ssl.BN_CTX_new()
+            if not ssl.EC_POINT_mul(group, pub_key, priv_key, None, None, ctx):
+                raise ValueError("Could not derive public key from the supplied secret.")
             ssl.EC_POINT_mul(group, pub_key, priv_key, None, None, ctx)
             ssl.EC_KEY_set_private_key(self.k, priv_key)
             ssl.EC_KEY_set_public_key(self.k, pub_key)
@@ -72,14 +74,15 @@ def get_pubkey(self):
         return mb.raw
 
     def sign(self, hash):
-        sig_size = ssl.ECDSA_size(self.k)
-        mb_sig = ctypes.create_string_buffer(sig_size)
-        sig_size0 = ctypes.POINTER(ctypes.c_int)()
-        assert 1 == ssl.ECDSA_sign(0, hash, len(hash), mb_sig, ctypes.byref(sig_size0), self.k)
-        return mb_sig.raw
+        sig_size0 = ctypes.c_uint32()
+        sig_size0.value = ssl.ECDSA_size(self.k)
+        mb_sig = ctypes.create_string_buffer(sig_size0.value)
+        result = ssl.ECDSA_sign(0, hash, len(hash), mb_sig, ctypes.byref(sig_size0), self.k)
+        assert 1 == result
+        return mb_sig.raw[:sig_size0.value]
 
     def verify(self, hash, sig):
-        return ssl.ECDSA_verify(0, hash, len(hash), sig, len(sig), self.k)
+        return ssl.ECDSA_verify(0, hash, len(hash), sig, len(sig), self.k) == 1
 
     def set_compressed(self, compressed):
         if compressed:
@@ -107,6 +110,10 @@ def set_compressed(self, compressed):
     k = CKey()
     k.generate (ec_secret.decode('hex'))
     k.set_compressed(True)
-    print k.get_privkey ().encode('hex')
-    print k.get_pubkey().encode('hex')
-    print k.get_secret().encode('hex')
+    print(k.get_privkey ().encode('hex'))
+    print(k.get_pubkey().encode('hex'))
+    # not sure this is needed any more: print k.get_secret().encode('hex')
+
+    hash = 'Hello, world!'
+    print(k.verify(hash, k.sign(hash)))
+
diff --git a/bitcoin/messages.py b/bitcoin/messages.py
index 6c88581..2b35569 100644
--- a/bitcoin/messages.py
+++ b/bitcoin/messages.py
@@ -6,6 +6,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
 import struct
 import time
 import random
@@ -17,7 +19,7 @@
 MSG_BLOCK = 2
 
 class msg_version(object):
-    command = "version"
+    command = b"version"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = MIN_PROTO_VERSION
         self.nVersion = protover
@@ -26,23 +28,23 @@ def __init__(self, protover=PROTO_VERSION):
         self.addrTo = CAddress(MIN_PROTO_VERSION)
         self.addrFrom = CAddress(MIN_PROTO_VERSION)
         self.nNonce = random.getrandbits(64)
-        self.strSubVer = '/python-bitcoin-0.0.1/'
+        self.strSubVer = b'/python-bitcoin-0.0.1/'
         self.nStartingHeight = -1
     def deserialize(self, f):
-        self.nVersion = struct.unpack("<i", f.read(4))[0]
+        self.nVersion = struct.unpack(b"<i", f.read(4))[0]
         if self.nVersion == 10300:
             self.nVersion = 300
-        self.nServices = struct.unpack("<Q", f.read(8))[0]
-        self.nTime = struct.unpack("<q", f.read(8))[0]
+        self.nServices = struct.unpack(b"<Q", f.read(8))[0]
+        self.nTime = struct.unpack(b"<q", f.read(8))[0]
         self.addrTo = CAddress(MIN_PROTO_VERSION)
         self.addrTo.deserialize(f)
         if self.nVersion >= 106:
             self.addrFrom = CAddress(MIN_PROTO_VERSION)
             self.addrFrom.deserialize(f)
-            self.nNonce = struct.unpack("<Q", f.read(8))[0]
+            self.nNonce = struct.unpack(b"<Q", f.read(8))[0]
             self.strSubVer = deser_string(f)
             if self.nVersion >= 209:
-                self.nStartingHeight = struct.unpack("<i", f.read(4))[0]
+                self.nStartingHeight = struct.unpack(b"<i", f.read(4))[0]
             else:
                 self.nStartingHeight = None
         else:
@@ -51,32 +53,32 @@ def deserialize(self, f):
             self.strSubVer = None
             self.nStartingHeight = None
     def serialize(self):
-        r = ""
-        r += struct.pack("<i", self.nVersion)
-        r += struct.pack("<Q", self.nServices)
-        r += struct.pack("<q", self.nTime)
+        r = b""
+        r += struct.pack(b"<i", self.nVersion)
+        r += struct.pack(b"<Q", self.nServices)
+        r += struct.pack(b"<q", self.nTime)
         r += self.addrTo.serialize()
         r += self.addrFrom.serialize()
-        r += struct.pack("<Q", self.nNonce)
+        r += struct.pack(b"<Q", self.nNonce)
         r += ser_string(self.strSubVer)
-        r += struct.pack("<i", self.nStartingHeight)
+        r += struct.pack(b"<i", self.nStartingHeight)
         return r
     def __repr__(self):
         return "msg_version(nVersion=%i nServices=%i nTime=%s addrTo=%s addrFrom=%s nNonce=0x%016X strSubVer=%s nStartingHeight=%i)" % (self.nVersion, self.nServices, time.ctime(self.nTime), repr(self.addrTo), repr(self.addrFrom), self.nNonce, self.strSubVer, self.nStartingHeight)
 
 class msg_verack(object):
-    command = "verack"
+    command = b"verack"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
     def deserialize(self, f):
         pass
     def serialize(self):
-        return ""
+        return b""
     def __repr__(self):
         return "msg_verack()"
 
 class msg_addr(object):
-    command = "addr"
+    command = b"addr"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.addrs = []
@@ -88,7 +90,7 @@ def __repr__(self):
         return "msg_addr(addrs=%s)" % (repr(self.addrs))
 
 class msg_alert(object):
-    command = "alert"
+    command = b"alert"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.alert = CAlert()
@@ -96,14 +98,14 @@ def deserialize(self, f):
         self.alert = CAlert()
         self.alert.deserialize(f)
     def serialize(self):
-        r = ""
+        r = b""
         r += self.alert.serialize()
         return r
     def __repr__(self):
         return "msg_alert(alert=%s)" % (repr(self.alert), )
 
 class msg_inv(object):
-    command = "inv"
+    command = b"inv"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.inv = []
@@ -115,7 +117,7 @@ def __repr__(self):
         return "msg_inv(inv=%s)" % (repr(self.inv))
 
 class msg_getdata(object):
-    command = "getdata"
+    command = b"getdata"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.inv = []
@@ -127,17 +129,17 @@ def __repr__(self):
         return "msg_getdata(inv=%s)" % (repr(self.inv))
 
 class msg_getblocks(object):
-    command = "getblocks"
+    command = b"getblocks"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.locator = CBlockLocator()
-        self.hashstop = 0L
+        self.hashstop = 0
     def deserialize(self, f):
         self.locator = CBlockLocator()
         self.locator.deserialize(f)
         self.hashstop = deser_uint256(f)
     def serialize(self):
-        r = ""
+        r = b""
         r += self.locator.serialize()
         r += ser_uint256(self.hashstop)
         return r
@@ -145,17 +147,17 @@ def __repr__(self):
         return "msg_getblocks(locator=%s hashstop=%064x)" % (repr(self.locator), self.hashstop)
 
 class msg_getheaders(object):
-    command = "getheaders"
+    command = b"getheaders"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.locator = CBlockLocator()
-        self.hashstop = 0L
+        self.hashstop = 0
     def deserialize(self, f):
         self.locator = CBlockLocator()
         self.locator.deserialize(f)
         self.hashstop = deser_uint256(f)
     def serialize(self):
-        r = ""
+        r = b""
         r += self.locator.serialize()
         r += ser_uint256(self.hashstop)
         return r
@@ -163,7 +165,7 @@ def __repr__(self):
         return "msg_getheaders(locator=%s hashstop=%064x)" % (repr(self.locator), self.hashstop)
 
 class msg_headers(object):
-    command = "headers"
+    command = b"headers"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.headers = []
@@ -175,7 +177,7 @@ def __repr__(self):
         return "msg_headers(headers=%s)" % (repr(self.headers))
 
 class msg_tx(object):
-    command = "tx"
+    command = b"tx"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.tx = CTransaction()
@@ -187,7 +189,7 @@ def __repr__(self):
         return "msg_tx(tx=%s)" % (repr(self.tx))
 
 class msg_block(object):
-    command = "block"
+    command = b"block"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
         self.block = CBlock()
@@ -199,13 +201,13 @@ def __repr__(self):
         return "msg_block(block=%s)" % (repr(self.block))
 
 class msg_getaddr(object):
-    command = "getaddr"
+    command = b"getaddr"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
     def deserialize(self, f):
         pass
     def serialize(self):
-        return ""
+        return b""
     def __repr__(self):
         return "msg_getaddr()"
 
@@ -214,43 +216,43 @@ def __repr__(self):
 #msg_reply
 
 class msg_ping(object):
-    command = "ping"
-    def __init__(self, protover=PROTO_VERSION, nonce=0L):
+    command = b"ping"
+    def __init__(self, protover=PROTO_VERSION, nonce=0):
         self.protover = protover
         self.nonce = nonce
     def deserialize(self, f):
         if self.protover > BIP0031_VERSION:
-            self.nonce = struct.unpack("<Q", f.read(8))[0]
+            self.nonce = struct.unpack(b"<Q", f.read(8))[0]
     def serialize(self):
-        r = ""
+        r = b""
         if self.protover > BIP0031_VERSION:
-            r += struct.pack("<Q", self.nonce)
+            r += struct.pack(b"<Q", self.nonce)
         return r
     def __repr__(self):
         return "msg_ping(0x%x)" % (self.nonce,)
 
 class msg_pong(object):
-    command = "pong"
-    def __init__(self, protover=PROTO_VERSION, nonce=0L):
+    command = b"pong"
+    def __init__(self, protover=PROTO_VERSION, nonce=0):
         self.protover = protover
         self.nonce = nonce
     def deserialize(self, f):
-        self.nonce = struct.unpack("<Q", f.read(8))[0]
+        self.nonce = struct.unpack(b"<Q", f.read(8))[0]
     def serialize(self):
-        r = ""
-        r += struct.pack("<Q", self.nonce)
+        r = b""
+        r += struct.pack(b"<Q", self.nonce)
         return r
     def __repr__(self):
         return "msg_pong(0x%x)" % (self.nonce,)
 
 class msg_mempool(object):
-    command = "mempool"
+    command = b"mempool"
     def __init__(self, protover=PROTO_VERSION):
         self.protover = protover
     def deserialize(self, f):
         pass
     def serialize(self):
-        return ""
+        return b""
     def __repr__(self):
         return "msg_mempool()"
 
@@ -287,8 +289,8 @@ def message_read(netmagic, f):
         return
 
     # remaining header fields: command, msg length, checksum
-    command = recvbuf[4:4+12].split("\x00", 1)[0]
-    msglen = struct.unpack("<i", recvbuf[4+12:4+12+4])[0]
+    command = recvbuf[4:4+12].split(b"\x00", 1)[0]
+    msglen = struct.unpack(b"<i", recvbuf[4+12:4+12+4])[0]
     checksum = recvbuf[4+12+4:4+12+4+4]
 
     # read message body
@@ -317,8 +319,8 @@ def message_to_str(netmagic, message):
     data = message.serialize()
     tmsg = netmagic.msg_start
     tmsg += command
-    tmsg += "\x00" * (12 - len(command))
-    tmsg += struct.pack("<I", len(data))
+    tmsg += b"\x00" * (12 - len(command))
+    tmsg += struct.pack(b"<I", len(data))
 
     # add checksum
     th = hashlib.sha256(data).digest()
diff --git a/bitcoin/rpc.py b/bitcoin/rpc.py
new file mode 100644
index 0000000..0a4f8bb
--- /dev/null
+++ b/bitcoin/rpc.py
@@ -0,0 +1,248 @@
+
+
+# Copyright 2011 Jeff Garzik
+#
+# RawProxy has the following improvements over python-jsonrpc's ServiceProxy
+# class:
+#
+# - HTTP connections persist for the life of the RawProxy object (if server
+#   supports HTTP/1.1)
+# - sends protocol 'version', per JSON-RPC 1.1
+# - sends proper, incrementing 'id'
+# - sends Basic HTTP authentication headers
+# - parses all JSON numbers that look like floats as Decimal
+# - uses standard Python json lib
+#
+# Previous copyright, from python-jsonrpc/jsonrpc/proxy.py:
+#
+# Copyright (c) 2007 Jan-Klaas Kollhof
+#
+# This file is part of jsonrpc.
+#
+# jsonrpc is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this software; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+try:
+    import http.client as httplib
+except ImportError:
+    import httplib
+import base64
+import decimal
+import json
+import os
+import platform
+try:
+    import urllib.parse as urlparse
+except ImportError:
+    import urlparse
+
+from bitcoin.coredefs import COIN
+from bitcoin.base58 import CBitcoinAddress
+
+USER_AGENT = "AuthServiceProxy/0.1"
+
+HTTP_TIMEOUT = 30
+
+
+class JSONRPCException(Exception):
+    def __init__(self, rpc_error):
+        super(JSONRPCException, self).__init__('msg: %r  code: %r' %
+                (rpc_error['message'], rpc_error['code']))
+        self.error = rpc_error
+
+
+class RawProxy(object):
+    # FIXME: need a CChainParams rather than hard-coded service_port
+    def __init__(self, service_url=None,
+                       service_port=8332,
+                       btc_conf_file=None,
+                       timeout=HTTP_TIMEOUT,
+                       _connection=None):
+        """Low-level JSON-RPC proxy
+
+        Unlike Proxy no conversion is done from the raw JSON objects.
+        """
+
+        if service_url is None:
+            # Figure out the path to the bitcoin.conf file
+            if btc_conf_file is None:
+                if platform.system() == 'Darwin':
+                    btc_conf_file = os.path.join(os.environ['APPDATA'], 'Bitcoin')
+                elif platform.system() == 'Windows':
+                    btc_conf_file = os.path.expanduser('~/Library/Application Support/Bitcoin/')
+                else:
+                    btc_conf_file = os.path.expanduser('~/.bitcoin')
+                btc_conf_file = os.path.join(btc_conf_file, 'bitcoin.conf')
+
+            # Extract contents of bitcoin.conf to build service_url
+            with open(btc_conf_file, 'r') as fd:
+                conf = {}
+                for line in fd.readlines():
+                    if '#' in line:
+                        line = line[:line.index('#')]
+                    if '=' not in line:
+                        continue
+                    k, v = line.split('=', 1)
+                    conf[k.strip()] = v.strip()
+
+                conf['rpcport'] = int(conf.get('rpcport', service_port))
+                conf['rpcssl'] = conf.get('rpcssl', '0')
+
+                if conf['rpcssl'].lower() in ('0', 'false'):
+                    conf['rpcssl'] = False
+                elif conf['rpcssl'].lower() in ('1', 'true'):
+                    conf['rpcssl'] = True
+                else:
+                    raise ValueError('Unknown rpcssl value %r' % conf['rpcssl'])
+
+                service_url = ('%s://%s:%s@localhost:%d' %
+                    ('https' if conf['rpcssl'] else 'http',
+                     conf['rpcuser'], conf['rpcpassword'],
+                     conf['rpcport']))
+
+        self.__service_url = service_url
+        self.__url = urlparse.urlparse(service_url)
+        if self.__url.port is None:
+            port = 80
+        else:
+            port = self.__url.port
+        self.__id_count = 0
+        authpair = "%s:%s" % (self.__url.username, self.__url.password)
+        authpair = authpair.encode('utf8')
+        self.__auth_header = b"Basic " + base64.b64encode(authpair)
+
+        if _connection:
+            # Callables re-use the connection of the original proxy
+            self.__conn = _connection
+        elif self.__url.scheme == 'https':
+            self.__conn = httplib.HTTPSConnection(self.__url.hostname, port,
+                                                  None, None, False,
+                                                  timeout)
+        else:
+            self.__conn = httplib.HTTPConnection(self.__url.hostname, port,
+                                                 False, timeout)
+
+
+    def _call(self, service_name, *args):
+        self.__id_count += 1
+
+        postdata = json.dumps({'version': '1.1',
+                               'method': service_name,
+                               'params': args,
+                               'id': self.__id_count})
+        self.__conn.request('POST', self.__url.path, postdata,
+                            {'Host': self.__url.hostname,
+                             'User-Agent': USER_AGENT,
+                             'Authorization': self.__auth_header,
+                             'Content-type': 'application/json'})
+
+        response = self._get_response()
+        if response['error'] is not None:
+            raise JSONRPCException(response['error'])
+        elif 'result' not in response:
+            raise JSONRPCException({
+                'code': -343, 'message': 'missing JSON-RPC result'})
+        else:
+            return response['result']
+
+
+    def __getattr__(self, name):
+        if name.startswith('__') and name.endswith('__'):
+            # Python internal stuff
+            raise AttributeError
+
+        # Create a callable to do the actual call
+        f = lambda *args: self._call(name, *args)
+
+        # Make debuggers show <function bitcoin.rpc.name> rather than <function
+        # bitcoin.rpc.<lambda>>
+        f.__name__ = name
+        return f
+
+
+    def _batch(self, rpc_call_list):
+        postdata = json.dumps(list(rpc_call_list))
+        self.__conn.request('POST', self.__url.path, postdata,
+                            {'Host': self.__url.hostname,
+                             'User-Agent': USER_AGENT,
+                             'Authorization': self.__auth_header,
+                             'Content-type': 'application/json'})
+
+        return self._get_response()
+
+    def _get_response(self):
+        http_response = self.__conn.getresponse()
+        if http_response is None:
+            raise JSONRPCException({
+                'code': -342, 'message': 'missing HTTP response from server'})
+
+        return json.loads(http_response.read().decode('utf8'),
+                          parse_float=decimal.Decimal)
+
+
+class Proxy(RawProxy):
+    def __init__(self, service_url=None,
+                       service_port=8332,
+                       btc_conf_file=None,
+                       timeout=HTTP_TIMEOUT,
+                       **kwargs):
+        """Create a proxy to a bitcoin RPC service
+
+        Unlike RawProxy data is passed as objects, rather than JSON. (not yet
+        fully implemented)
+
+        If service_url is not specified the username and password are read out
+        of the file btc_conf_file. If btc_conf_file is not specified
+        ~/.bitcoin/bitcoin.conf or equivalent is used by default.
+
+        Usually no arguments to Proxy() are needed; the local bitcoind will be
+        used.
+
+        timeout - timeout in seconds before the HTTP interface times out
+        """
+        super(Proxy, self).__init__(service_url=service_url, service_port=service_port, btc_conf_file=btc_conf_file,
+                                    timeout=HTTP_TIMEOUT,
+                                    **kwargs)
+
+    def getinfo(self):
+        """Returns an object containing various state info"""
+        r = self._call('getinfo')
+        r['balance'] = int(r['balance'] * COIN)
+        r['paytxfee'] = int(r['paytxfee'] * COIN)
+        return r
+
+    def getnewaddress(self, account=None):
+        """Return a new Bitcoin address for receiving payments.
+
+        If account is not None, it is added to the address book so payments
+        received with the address will be credited to account.
+        """
+        r = None
+        if account is not None:
+            r = self._call('getnewaddress', account)
+        else:
+            r = self._call('getnewaddress')
+
+        return CBitcoinAddress.from_str(r)
+
+    def getaccountaddress(self, account=None):
+        """Return the current Bitcoin address for receiving payments to this account."""
+        r = self._call('getaccountaddress', account)
+        return CBitcoinAddress.from_str(r)
+
+    def validateaddress(self, address):
+        """Return information about an address"""
+        r = self._call('validateaddress', str(address))
+        r['address'] = CBitcoinAddress.from_str(r['address'])
+        return r
diff --git a/bitcoin/script.py b/bitcoin/script.py
index 88721d2..da27059 100644
--- a/bitcoin/script.py
+++ b/bitcoin/script.py
@@ -6,6 +6,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
 import struct
 
 SIGHASH_ALL = 1
@@ -462,14 +464,14 @@ def getop(self):
             s = self.getchars(2)
             if s is None:
                 return False
-            datasize = struct.unpack("<H", s)[0]
+            datasize = struct.unpack(b"<H", s)[0]
 
         elif opcode == OP_PUSHDATA4:
             sop.ser_len += 4
             s = self.getchars(4)
             if s is None:
                 return False
-            datasize = struct.unpack("<I", s)[0]
+            datasize = struct.unpack(b"<I", s)[0]
 
         sop.ser_len += datasize
         sop.data = self.getchars(datasize)
@@ -491,38 +493,38 @@ def tokenize(self, vch_in=None):
         return True
 
     def match_temp(self, template, vch_in=None):
-	l = []
-	i = 0
+        l = []
+        i = 0
 
         if vch_in is not None:
             self.vch = vch_in
 
         self.reset()
         while self.pc < self.pend:
-	    if i >= len(template):
-	    	return None
+            if i >= len(template):
+                return None
             if not self.getop():
                 return None
-	
-	    expected_op = template[i]
-	    if expected_op == OP_PUBKEYHASH or expected_op == OP_PUBKEY:
-	    	if self.sop.op > OP_PUSHDATA4:
-		    return None
-		l.append(self.sop.data)
 
-	    elif self.sop.op != expected_op:
-	    	return None
+            expected_op = template[i]
+            if expected_op == OP_PUBKEYHASH or expected_op == OP_PUBKEY:
+                if self.sop.op > OP_PUSHDATA4:
+                    return None
+                l.append(self.sop.data)
+
+            elif self.sop.op != expected_op:
+                return None
 
-	    i += 1
+            i += 1
 
         return l
 
     def match_alltemp(self, vch_in=None):
         for temp in TEMPLATES:
-	    l = self.match_temp(temp, vch_in)
-	    if l is not None:
-	    	return l
-	return None
+            l = self.match_temp(temp, vch_in)
+            if l is not None:
+                return l
+        return None
 
     def __repr__(self):
         return "CScript(vchsz %d)" % (len(self.vch),)
diff --git a/bitcoin/scripteval.py b/bitcoin/scripteval.py
index d65c73e..f104920 100644
--- a/bitcoin/scripteval.py
+++ b/bitcoin/scripteval.py
@@ -6,6 +6,12 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import sys
+if sys.version > '3':
+    long = int
+
 import hashlib
 from bitcoin.serialize import Hash, Hash160, ser_uint256, ser_uint160
 from bitcoin.script import *
@@ -15,33 +21,33 @@
 
 def SignatureHash(script, txTo, inIdx, hashtype):
     if inIdx >= len(txTo.vin):
-        return (0L, "inIdx %d out of range (%d)" % (inIdx, len(txTo.vin)))
+        return (1, "inIdx %d out of range (%d)" % (inIdx, len(txTo.vin)))
     txtmp = CTransaction()
     txtmp.copy(txTo)
 
     for txin in txtmp.vin:
-        txin.scriptSig = ''
+        txin.scriptSig = b''
     txtmp.vin[inIdx].scriptSig = script.vch
 
     if (hashtype & 0x1f) == SIGHASH_NONE:
         txtmp.vout = []
 
-        for i in xrange(len(txtmp.vin)):
+        for i in range(len(txtmp.vin)):
             if i != inIdx:
                 txtmp.vin[i].nSequence = 0
 
     elif (hashtype & 0x1f) == SIGHASH_SINGLE:
         outIdx = inIdx
         if outIdx >= len(txtmp.vout):
-            return (0L, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout)))
+            return (1, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout)))
 
         tmp = txtmp.vout[outIdx]
         txtmp.vout = []
-        for i in xrange(outIdx):
+        for i in range(outIdx):
             txtmp.vout.append(CTxOut())
         txtmp.vout.append(tmp)
 
-        for i in xrange(len(txtmp.vin)):
+        for i in range(len(txtmp.vin)):
             if i != inIdx:
                 txtmp.vin[i].nSequence = 0
 
@@ -51,7 +57,7 @@ def SignatureHash(script, txTo, inIdx, hashtype):
         txtmp.vin.append(tmp)
 
     s = txtmp.serialize()
-    s += struct.pack("<I", hashtype)
+    s += struct.pack(b"<I", hashtype)
 
     hash = Hash(s)
 
@@ -70,8 +76,6 @@ def CheckSig(sig, pubkey, script, txTo, inIdx, hashtype):
     sig = sig[:-1]
 
     tup = SignatureHash(script, txTo, inIdx, hashtype)
-    if tup[0] == 0L:
-        return False
     return key.verify(ser_uint256(tup[0]), sig)
 
 def CheckMultiSig(opcode, script, stack, txTo, inIdx, hashtype):
@@ -97,7 +101,7 @@ def CheckMultiSig(opcode, script, stack, txTo, inIdx, hashtype):
     if len(stack) < i:
         return False
 
-    for k in xrange(sigs_count):
+    for k in range(sigs_count):
         sig = stack[-isig-k]
         # FIXME: find-and-delete sig in script
 
@@ -122,9 +126,9 @@ def CheckMultiSig(opcode, script, stack, txTo, inIdx, hashtype):
         i -= 1
 
     if success:
-        stack.append("\x01")
+        stack.append(b"\x01")
     else:
-        stack.append("\x00")
+        stack.append(b"\x00")
 
     if opcode == OP_CHECKMULTISIGVERIFY:
         if success:
@@ -136,7 +140,7 @@ def CheckMultiSig(opcode, script, stack, txTo, inIdx, hashtype):
 
 def dumpstack(msg, stack):
     print("%s stacksz %d" % (msg, len(stack)))
-    for i in xrange(len(stack)):
+    for i in range(len(stack)):
         vch = stack[i]
         print("#%d: %s" % (i, vch.encode('hex')))
 
@@ -176,10 +180,10 @@ def UnaryOp(opcode, stack):
             bn = -bn
 
     elif opcode == OP_NOT:
-        bn = long(bn == 0L)
+        bn = long(bn == 0)
 
     elif opcode == OP_0NOTEQUAL:
-        bn = long(bn != 0L)
+        bn = long(bn != 0)
 
     else:
         return False
@@ -230,10 +234,10 @@ def BinOp(opcode, stack):
         bn = bn1 >> bn2
 
     elif opcode == OP_BOOLAND:
-        bn = long(bn1 != 0L and bn2 != 0L)
+        bn = long(bn1 != 0 and bn2 != 0)
 
     elif opcode == OP_BOOLOR:
-        bn = long(bn1 != 0L or bn2 != 0L)
+        bn = long(bn1 != 0 or bn2 != 0)
 
     elif opcode == OP_NUMEQUAL or opcode == OP_NUMEQUALVERIFY:
         bn = long(bn1 == bn2)
@@ -374,11 +378,11 @@ def EvalScript(stack, scriptIn, txTo, inIdx, hashtype):
                       txTo, inIdx, hashtype)
             if ok:
                 if sop.op != OP_CHECKSIGVERIFY:
-                    stack.append("\x01")
+                    stack.append(b"\x01")
             else:
                 if sop.op == OP_CHECKSIGVERIFY:
                     return False
-                stack.append("\x00")
+                stack.append(b"\x00")
 
         elif fExec and sop.op == OP_CODESEPARATOR:
             script.pbegincodehash = script.pc
@@ -416,9 +420,9 @@ def EvalScript(stack, scriptIn, txTo, inIdx, hashtype):
 
             is_equal = (v1 == v2)
             if is_equal:
-                stack.append("\x01")
+                stack.append(b"\x01")
             else:
-                stack.append("\x00")
+                stack.append(b"\x00")
 
             if sop.op == OP_EQUALVERIFY:
                 if is_equal:
@@ -556,9 +560,9 @@ def EvalScript(stack, scriptIn, txTo, inIdx, hashtype):
             bn1 = CastToBigNum(stack.pop())
             v = (bn2 <= bn1) and (bn1 < bn3)
             if v:
-                stack.append("\x01")
+                stack.append(b"\x01")
             else:
-                stack.append("\x00")
+                stack.append(b"\x00")
 
         elif fExec:
             #print("Unsupported opcode", OPCODE_NAMES[sop.op])
@@ -571,7 +575,7 @@ def CastToBigNum(s):
     return v
 
 def CastToBool(s):
-    for i in xrange(len(s)):
+    for i in range(len(s)):
         sv = ord(s[i])
         if sv != 0:
             if (i == (len(s) - 1)) and (sv == 0x80):
diff --git a/bitcoin/serialize.py b/bitcoin/serialize.py
index 240d8bd..7734dac 100644
--- a/bitcoin/serialize.py
+++ b/bitcoin/serialize.py
@@ -6,66 +6,74 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
+from __future__ import absolute_import, division, print_function, unicode_literals
+
 import struct
 import hashlib
 
+# Py3 compatibility
+import sys
+bchr = chr
+if sys.version > '3':
+    bchr = lambda x: bytes([x])
+
 def deser_string(f):
-    nit = struct.unpack("<B", f.read(1))[0]
+    nit = struct.unpack(b"<B", f.read(1))[0]
     if nit == 253:
-        nit = struct.unpack("<H", f.read(2))[0]
+        nit = struct.unpack(b"<H", f.read(2))[0]
     elif nit == 254:
-        nit = struct.unpack("<I", f.read(4))[0]
+        nit = struct.unpack(b"<I", f.read(4))[0]
     elif nit == 255:
-        nit = struct.unpack("<Q", f.read(8))[0]
+        nit = struct.unpack(b"<Q", f.read(8))[0]
     return f.read(nit)
 
 def ser_string(s):
     if len(s) < 253:
-        return chr(len(s)) + s
+        return bchr(len(s)) + s
     elif len(s) < 0x10000:
-        return chr(253) + struct.pack("<H", len(s)) + s
-    elif len(s) < 0x100000000L:
-        return chr(254) + struct.pack("<I", len(s)) + s
-    return chr(255) + struct.pack("<Q", len(s)) + s
+        return bchr(253) + struct.pack(b"<H", len(s)) + s
+    elif len(s) < 0x100000000:
+        return bchr(254) + struct.pack(b"<I", len(s)) + s
+    return bchr(255) + struct.pack(b"<Q", len(s)) + s
 
 def deser_uint256(f):
-    r = 0L
-    for i in xrange(8):
-        t = struct.unpack("<I", f.read(4))[0]
+    r = 0
+    for i in range(8):
+        t = struct.unpack(b"<I", f.read(4))[0]
         r += t << (i * 32)
     return r
 
 def ser_uint256(u):
-    rs = ""
-    for i in xrange(8):
-        rs += struct.pack("<I", u & 0xFFFFFFFFL)
+    rs = b""
+    for i in range(8):
+        rs += struct.pack(b"<I", u & 0xFFFFFFFF)
         u >>= 32
     return rs
 
 def ser_uint160(u):
-    rs = ""
-    for i in xrange(5):
-        rs += struct.pack("<I", u & 0xFFFFFFFFL)
+    rs = b""
+    for i in range(5):
+        rs += struct.pack(b"<I", u & 0xFFFFFFFF)
         u >>= 32
     return rs
 
 def uint160_from_str(s):
-    r = 0L
-    t = struct.unpack("<IIIII", s[:20])
-    for i in xrange(5):
+    r = 0
+    t = struct.unpack(b"<IIIII", s[:20])
+    for i in range(5):
         r += t[i] << (i * 32)
     return r
 
 def uint256_from_str(s):
-    r = 0L
-    t = struct.unpack("<IIIIIIII", s[:32])
-    for i in xrange(8):
+    r = 0
+    t = struct.unpack(b"<IIIIIIII", s[:32])
+    for i in range(8):
         r += t[i] << (i * 32)
     return r
 
 def uint256_from_compact(c):
     nbytes = (c >> 24) & 0xFF
-    v = (c & 0xFFFFFFL) << (8 * (nbytes - 3))
+    v = (c & 0xFFFFFF) << (8 * (nbytes - 3))
     return v
 
 def uint256_to_shortstr(u):
@@ -73,15 +81,15 @@ def uint256_to_shortstr(u):
     return s[:16]
 
 def deser_vector(f, c, arg1=None):
-    nit = struct.unpack("<B", f.read(1))[0]
+    nit = struct.unpack(b"<B", f.read(1))[0]
     if nit == 253:
-        nit = struct.unpack("<H", f.read(2))[0]
+        nit = struct.unpack(b"<H", f.read(2))[0]
     elif nit == 254:
-        nit = struct.unpack("<I", f.read(4))[0]
+        nit = struct.unpack(b"<I", f.read(4))[0]
     elif nit == 255:
-        nit = struct.unpack("<Q", f.read(8))[0]
+        nit = struct.unpack(b"<Q", f.read(8))[0]
     r = []
-    for i in xrange(nit):
+    for i in range(nit):
         if arg1 is not None:
             t = c(arg1)
         else:
@@ -91,101 +99,101 @@ def deser_vector(f, c, arg1=None):
     return r
 
 def ser_vector(l):
-    r = ""
+    r = b""
     if len(l) < 253:
-        r = chr(len(l))
+        r = bchr(len(l))
     elif len(l) < 0x10000:
-        r = chr(253) + struct.pack("<H", len(l))
-    elif len(l) < 0x100000000L:
-        r = chr(254) + struct.pack("<I", len(l))
+        r = bchr(253) + struct.pack(b"<H", len(l))
+    elif len(l) < 0x100000000:
+        r = bchr(254) + struct.pack(b"<I", len(l))
     else:
-        r = chr(255) + struct.pack("<Q", len(l))
+        r = bchr(255) + struct.pack(b"<Q", len(l))
     for i in l:
         r += i.serialize()
     return r
 
 def deser_uint256_vector(f):
-    nit = struct.unpack("<B", f.read(1))[0]
+    nit = struct.unpack(b"<B", f.read(1))[0]
     if nit == 253:
-        nit = struct.unpack("<H", f.read(2))[0]
+        nit = struct.unpack(b"<H", f.read(2))[0]
     elif nit == 254:
-        nit = struct.unpack("<I", f.read(4))[0]
+        nit = struct.unpack(b"<I", f.read(4))[0]
     elif nit == 255:
-        nit = struct.unpack("<Q", f.read(8))[0]
+        nit = struct.unpack(b"<Q", f.read(8))[0]
     r = []
-    for i in xrange(nit):
+    for i in range(nit):
         t = deser_uint256(f)
         r.append(t)
     return r
 
 def ser_uint256_vector(l):
-    r = ""
+    r = b""
     if len(l) < 253:
-        r = chr(len(l))
+        r = bchr(len(l))
     elif len(s) < 0x10000:
-        r = chr(253) + struct.pack("<H", len(l))
-    elif len(s) < 0x100000000L:
-        r = chr(254) + struct.pack("<I", len(l))
+        r = bchr(253) + struct.pack(b"<H", len(l))
+    elif len(s) < 0x100000000:
+        r = bchr(254) + struct.pack(b"<I", len(l))
     else:
-        r = chr(255) + struct.pack("<Q", len(l))
+        r = bchr(255) + struct.pack(b"<Q", len(l))
     for i in l:
         r += ser_uint256(i)
     return r
 
 def deser_string_vector(f):
-    nit = struct.unpack("<B", f.read(1))[0]
+    nit = struct.unpack(b"<B", f.read(1))[0]
     if nit == 253:
-        nit = struct.unpack("<H", f.read(2))[0]
+        nit = struct.unpack(b"<H", f.read(2))[0]
     elif nit == 254:
-        nit = struct.unpack("<I", f.read(4))[0]
+        nit = struct.unpack(b"<I", f.read(4))[0]
     elif nit == 255:
-        nit = struct.unpack("<Q", f.read(8))[0]
+        nit = struct.unpack(b"<Q", f.read(8))[0]
     r = []
-    for i in xrange(nit):
+    for i in range(nit):
         t = deser_string(f)
         r.append(t)
     return r
 
 def ser_string_vector(l):
-    r = ""
+    r = b""
     if len(l) < 253:
-        r = chr(len(l))
+        r = bchr(len(l))
     elif len(s) < 0x10000:
-        r = chr(253) + struct.pack("<H", len(l))
-    elif len(s) < 0x100000000L:
-        r = chr(254) + struct.pack("<I", len(l))
+        r = bchr(253) + struct.pack(b"<H", len(l))
+    elif len(s) < 0x100000000:
+        r = bchr(254) + struct.pack(b"<I", len(l))
     else:
-        r = chr(255) + struct.pack("<Q", len(l))
+        r = bchr(255) + struct.pack(b"<Q", len(l))
     for sv in l:
         r += ser_string(sv)
     return r
 
 def deser_int_vector(f):
-    nit = struct.unpack("<B", f.read(1))[0]
+    nit = struct.unpack(b"<B", f.read(1))[0]
     if nit == 253:
-        nit = struct.unpack("<H", f.read(2))[0]
+        nit = struct.unpack(b"<H", f.read(2))[0]
     elif nit == 254:
-        nit = struct.unpack("<I", f.read(4))[0]
+        nit = struct.unpack(b"<I", f.read(4))[0]
     elif nit == 255:
-        nit = struct.unpack("<Q", f.read(8))[0]
+        nit = struct.unpack(b"<Q", f.read(8))[0]
     r = []
-    for i in xrange(nit):
-        t = struct.unpack("<i", f.read(4))[0]
+    for i in range(nit):
+        t = struct.unpack(b"<i", f.read(4))[0]
         r.append(t)
     return r
 
 def ser_int_vector(l):
-    r = ""
+    r = b""
     if len(l) < 253:
-        r = chr(len(l))
+        r = bchr(len(l))
     elif len(s) < 0x10000:
-        r = chr(253) + struct.pack("<H", len(l))
-    elif len(s) < 0x100000000L:
-        r = chr(254) + struct.pack("<I", len(l))
+        r = bchr(253) + struct.pack(b"<H", len(l))
+    elif len(s) < 0x100000000:
+        r = bchr(254) + struct.pack(b"<I", len(l))
     else:
-        r = chr(255) + struct.pack("<Q", len(l))
+        r = bchr(255) + struct.pack(b"<Q", len(l))
     for i in l:
-        r += struct.pack("<i", i)
+        r += struct.pack(b"<i", i)
     return r
 
 def Hash(s):
diff --git a/bitcoin/tests/__init__.py b/bitcoin/tests/__init__.py
index 4b8b80f..27fe8df 100644
--- a/bitcoin/tests/__init__.py
+++ b/bitcoin/tests/__init__.py
@@ -1,2 +1,4 @@
 # Distributed under the MIT/X11 software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from __future__ import absolute_import, division, print_function, unicode_literals
diff --git a/bitcoin/tests/test_base58.py b/bitcoin/tests/test_base58.py
index cabdaa3..2acf72d 100644
--- a/bitcoin/tests/test_base58.py
+++ b/bitcoin/tests/test_base58.py
@@ -1,7 +1,7 @@
 # Distributed under the MIT/X11 software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-from __future__ import print_function
+from __future__ import absolute_import, division, print_function, unicode_literals
 
 import json
 import os
@@ -20,7 +20,7 @@ def load_test_vector(name):
 class Test_base58(unittest.TestCase):
     def test_encode_decode(self):
         for exp_bin, exp_base58 in load_test_vector('base58_encode_decode.json'):
-            exp_bin = unhexlify(exp_bin)
+            exp_bin = unhexlify(exp_bin.encode('utf8'))
 
             act_base58 = encode(exp_bin)
             act_bin = decode(exp_base58)
diff --git a/bitcoin/tests/test_bloom.py b/bitcoin/tests/test_bloom.py
new file mode 100644
index 0000000..5e4b477
--- /dev/null
+++ b/bitcoin/tests/test_bloom.py
@@ -0,0 +1,67 @@
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import json
+import os
+import unittest
+
+from binascii import unhexlify
+
+from bitcoin.bloom import *
+
+class Test_CBloomFilter(unittest.TestCase):
+    def test_create_insert_serialize(self):
+        filter = CBloomFilter(3, 0.01, 0, CBloomFilter.UPDATE_ALL)
+
+        def T(elem):
+            """Filter contains elem"""
+            elem = unhexlify(elem)
+            filter.insert(elem)
+            self.assertTrue(filter.contains(elem))
+
+        def F(elem):
+            """Filter does not contain elem"""
+            elem = unhexlify(elem)
+            self.assertFalse(filter.contains(elem))
+
+        T(b'99108ad8ed9bb6274d3980bab5a85c048f0950c8')
+        F(b'19108ad8ed9bb6274d3980bab5a85c048f0950c8')
+        T(b'b5a2c786d9ef4658287ced5914b37a1b4aa32eee')
+        T(b'b9300670b4c5366e95b2699e8b18bc75e5f729c5')
+
+        self.assertEqual(filter.serialize(), unhexlify(b'03614e9b050000000000000001'))
+
+    def test_create_insert_serialize_with_tweak(self):
+        # Same test as bloom_create_insert_serialize, but we add a nTweak of 100
+        filter = CBloomFilter(3, 0.01, 2147483649, CBloomFilter.UPDATE_ALL)
+
+        def T(elem):
+            """Filter contains elem"""
+            elem = unhexlify(elem)
+            filter.insert(elem)
+            self.assertTrue(filter.contains(elem))
+
+        def F(elem):
+            """Filter does not contain elem"""
+            elem = unhexlify(elem)
+            self.assertFalse(filter.contains(elem))
+
+        T(b'99108ad8ed9bb6274d3980bab5a85c048f0950c8')
+        F(b'19108ad8ed9bb6274d3980bab5a85c048f0950c8')
+        T(b'b5a2c786d9ef4658287ced5914b37a1b4aa32eee')
+        T(b'b9300670b4c5366e95b2699e8b18bc75e5f729c5')
+
+        self.assertEqual(filter.serialize(), unhexlify(b'03ce4299050000000100008001'))
+
+    def test_bloom_create_insert_key(self):
+        filter = CBloomFilter(2, 0.001, 0, CBloomFilter.UPDATE_ALL)
+
+        pubkey = unhexlify(b'045B81F0017E2091E2EDCD5EECF10D5BDD120A5514CB3EE65B8447EC18BFC4575C6D5BF415E54E03B1067934A0F0BA76B01C6B9AB227142EE1D543764B69D901E0')
+        pubkeyhash = ser_uint160(Hash160(pubkey))
+
+        filter.insert(pubkey)
+        filter.insert(pubkeyhash)
+
+        self.assertEqual(filter.serialize(), unhexlify(b'038fc16b080000000000000001'))
diff --git a/bitcoin/tests/test_hash.py b/bitcoin/tests/test_hash.py
new file mode 100644
index 0000000..500216b
--- /dev/null
+++ b/bitcoin/tests/test_hash.py
@@ -0,0 +1,34 @@
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import json
+import os
+import unittest
+
+from binascii import unhexlify
+
+from bitcoin.hash import *
+
+class Test_MurmurHash3(unittest.TestCase):
+    def test(self):
+        def T(expected, seed, data):
+            self.assertEqual(MurmurHash3(seed, unhexlify(data)), expected)
+
+        T(0x00000000, 0x00000000, b"");
+        T(0x6a396f08, 0xFBA4C795, b"");
+        T(0x81f16f39, 0xffffffff, b"");
+
+        T(0x514e28b7, 0x00000000, b"00");
+        T(0xea3f0b17, 0xFBA4C795, b"00");
+        T(0xfd6cf10d, 0x00000000, b"ff");
+
+        T(0x16c6b7ab, 0x00000000, b"0011");
+        T(0x8eb51c3d, 0x00000000, b"001122");
+        T(0xb4471bf8, 0x00000000, b"00112233");
+        T(0xe2301fa8, 0x00000000, b"0011223344");
+        T(0xfc2e4a15, 0x00000000, b"001122334455");
+        T(0xb074502c, 0x00000000, b"00112233445566");
+        T(0x8034d2a0, 0x00000000, b"0011223344556677");
+        T(0xb4698def, 0x00000000, b"001122334455667788");