import sys
import socket
import struct
import random
import hashlib
from binascii import hexlify, unhexlify
import time
from codecs import encode
from threading import RLock
from io import BytesIO
import copy
from test_framework.siphash import siphash256
import test_framework.util as util

MY_VERSION = 70014 # past bip-252 for compactblocks

from .constants import SIGHASH_ALL, \
    SIGHASH_FORKID, SIGHASH_ANYONECANPAY, \
    SIGHASH_SINGLE, SIGHASH_NONE

MY_SUBVERSION = b"/python-mininode-tester:0.0.3/"

COIN = 100000000  # 1 btc in satoshis

# One lock for synchronizing all data access between the networking thread (see
# NetworkThread below) and the thread running the test logic.  For simplicity,
# NodeConn acquires this lock whenever delivering a message to a NodeConnCB,
# and whenever adding anything to the send buffer (in send_message()).  This
# lock should be acquired in the thread running the test logic to synchronize
# access to any data shared with the NodeConnCB or NodeConn.
mininode_lock = RLock()

# Helper function

# These functions were moved to util, but keep them in this namespace for backwards compatibility
sha256 = util.sha256
hash256 = util.hash256
hash160 = util.hash160

def wait_until(predicate, attempts=float('inf'), timeout=float('inf')):
    attempt = 0
    elapsed = 0

    while attempt < attempts and elapsed < timeout:
        with mininode_lock:
            if predicate():
                return True
        attempt += 1
        elapsed += 0.05
        time.sleep(0.05)

    return False

def bitcoinAddress2bin(btcAddress):
    """convert a bitcoin address to binary data capable of being put in a CScript"""
    # chop the version and checksum out of the bytes of the address
    return decodeBase58(btcAddress)[1:-4]

B58_DIGITS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

class InvalidBase58Error(Exception):
    """Raised on generic invalid base58 data, such as bad characters.
    Checksum failures raise Base58ChecksumError specifically.
    """
    pass

def decodeBase58(s):
    """Decode a base58-encoding string, returning bytes"""
    if not s:
        return b''

    # Convert the string to an integer
    n = 0
    for c in s:
        n *= 58
        if c not in B58_DIGITS:
            raise InvalidBase58Error('Character %r is not a valid base58 character' % c)
        digit = B58_DIGITS.index(c)
        n += digit

    # Convert the integer to bytes
    h = '%x' % n
    if len(h) % 2:
        h = '0' + h
    res = unhexlify(h.encode('utf8'))

    # Add padding back.
    pad = 0
    for c in s[:-1]:
        if c == B58_DIGITS[0]:
            pad += 1
        else:
            break
    return b'\x00' * pad + res


def encodeBase58(b):
    """Encode bytes to a base58-encoded string"""

    # Convert big-endian bytes to integer
    n = int('0x0' + hexlify(b).decode('utf8'), 16)

    # Divide that integer into bas58
    res = []
    while n > 0:
        n, r = divmod(n, 58)
        res.append(B58_DIGITS[r])
    res = ''.join(res[::-1])

    # Encode leading zeros as base58 zeros
    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 == czero:
            pad += 1
        else:
            break
    return B58_DIGITS[0] * pad + res

def encodeBitcoinAddress(prefix, data):
    data2 = prefix + data
    cksm = hash256(data2)[:4]
    data3 = data2 + cksm
    b58 = encodeBase58(data3)
    return b58


class CompactSize(int):
    def serialize(self):
        assert(self>=0)
        if self<253:
            return struct.pack("<B", self)
        elif self<2**16:
            return struct.pack("<B", 253) + struct.pack("<H", self)
        elif self<2**32:
            return struct.pack("<B", 254) + struct.pack("<I", self)
        elif self<2**64:
            return struct.pack("<B", 255) + struct.pack("<Q", self)

    def deserialize(self, f):
        self = struct.unpack("<B", f.read(1))[0]
        if self == 253:
            self = struct.unpack("<H", f.read(2))[0]
        elif self == 254:
            self = struct.unpack("<I", f.read(4))[0]
        elif self == 255:
            self = struct.unpack("<Q", f.read(8))[0]
        return self

def deser_string(f):
    """Convert an array of bytes in the bitcoin P2P protocol format into a string

    >>> import io
    >>> deser_string(io.BytesIO(ser_string("The grid bug bites!  You get zapped!".encode()))).decode()
    'The grid bug bites!  You get zapped!'
    """
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    return f.read(nit)


def ser_string(s):
    """convert a string into an array of bytes (in the bitcoin network format)

       >>> ser_string("The grid bug bites!  You get zapped!".encode())
       b'$The grid bug bites!  You get zapped!'
    """
    if len(s) < 253:
        return struct.pack("B", len(s)) + s
    elif len(s) < 0x10000:
        return struct.pack("<BH", 253, len(s)) + s
    elif len(s) < 0x100000000:
        return struct.pack("<BI", 254, len(s)) + s
    return struct.pack("<BQ", 255, len(s)) + s


def deser_uint256(f):
    r = 0
    for i in range(8):
        t = struct.unpack("<I", f.read(4))[0]
        r += t << (i * 32)
    return r


def ser_uint256(u):
    rs = b""
    for i in range(8):
        rs += struct.pack("<I", u & 0xFFFFFFFF)
        u >>= 32
    return rs


def uint256_from_str(s):
    r = 0
    t = struct.unpack("<IIIIIIII", s[:32])
    for i in range(8):
        r += t[i] << (i * 32)
    return r

def uint256_from_bigendian(s):
    """Decode a uint256 from a big-endian byte array or hex string (lexical order is big-endian)
    """
    if type(s) is str:
        s = unhexlify(s)
    r = 0
    t = struct.unpack(">QQQQ", s[:32])
    for i in t:
        r = (r << 64) | i
    return r


def uint256_from_compact(c):
    nbytes = (c >> 24) & 0xFF
    v = (c & 0xFFFFFF) << (8 * (nbytes - 3))
    return v


def deser_vector(f, c):
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    r = []
    for i in range(nit):
        t = c()
        t.deserialize(f)
        r.append(t)
    return r


def ser_vector(l):
    r = b""
    if len(l) < 253:
        r = struct.pack("B", len(l))
    elif len(l) < 0x10000:
        r = struct.pack("<BH", 253, len(l))
    elif len(l) < 0x100000000:
        r = struct.pack("<BI", 254, len(l))
    else:
        r = struct.pack("<BQ", 255, len(l))
    for i in l:
        r += i.serialize()
    return r


def deser_uint256_vector(f):
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    r = []
    for i in range(nit):
        t = deser_uint256(f)
        r.append(t)
    return r


def ser_uint256_vector(l):
    r = b""
    if len(l) < 253:
        r = struct.pack("B", len(l))
    elif len(l) < 0x10000:
        r = struct.pack("<BH", 253, len(l))
    elif len(l) < 0x100000000:
        r = struct.pack("<BI", 254, len(l))
    else:
        r = struct.pack("<BQ", 255, len(l))
    for i in l:
        r += ser_uint256(i)
    return r

def ser_compact_size(l):
    r = b""
    if l < 253:
        r = struct.pack("B", l)
    elif l < 0x10000:
        r = struct.pack("<BH", 253, l)
    elif l < 0x100000000:
        r = struct.pack("<BI", 254, l)
    else:
        r = struct.pack("<BQ", 255, l)
    return r

def deser_compact_size(f):
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    return nit

def deser_string_vector(f):
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    r = []
    for i in range(nit):
        t = deser_string(f)
        r.append(t)
    return r


def ser_string_vector(l):
    r = b""
    if len(l) < 253:
        r = struct.pack("B", len(l))
    elif len(l) < 0x10000:
        r = struct.pack("<BH", 253, len(l))
    elif len(l) < 0x100000000:
        r = struct.pack("<BI", 254, len(l))
    else:
        r = struct.pack("<BQ", 255, 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]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    r = []
    for i in range(nit):
        t = struct.unpack("<i", f.read(4))[0]
        r.append(t)
    return r


def ser_int_vector(l):
    r = b""
    if len(l) < 253:
        r = struct.pack("B", len(l))
    elif len(l) < 0x10000:
        r = struct.pack("<BH", 253, len(l))
    elif len(l) < 0x100000000:
        r = struct.pack("<BI", 254, len(l))
    else:
        r = struct.pack("<BQ", 255, len(l))
    for i in l:
        r += struct.pack("<i", i)
    return r

# Deserialize from a hex string representation (eg from RPC)


def FromHex(obj, hex_string):
    obj.deserialize(BytesIO(unhexlify(hex_string.encode('ascii'))))
    return obj

# Convert a binary-serializable object to hex (eg for submission via RPC)


def ToHex(obj):
    return hexlify(obj.serialize()).decode('ascii')


# Objects that map to bitcoind objects, which can be serialized/deserialized

# because the nVersion field has not been passed before the VERSION message the protocol uses an old format for the CAddress (missing nTime)
# This class handles that old format
class CAddressInVersion(object):
    def __init__(self, ip="0.0.0.0", port=0):
        self.nServices = 1
        self.pchReserved = b"\x00" * 10 + b"\xff" * 2  # ip is 16 bytes on wire to handle v6
        self.ip = ip
        self.port = port

    def deserialize(self, f):
        self.nServices = struct.unpack("<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]

    def serialize(self):
        r = b""
        r += struct.pack("<Q", self.nServices)
        r += self.pchReserved
        r += socket.inet_aton(self.ip)
        r += struct.pack(">H", self.port)
        return r

    def __repr__(self):
        return "CAddressInVersion(nServices=%i ip=%s port=%i)" % (self.nServices, self.ip, self.port)

# Handle new-style CAddress objects (with nTime)
class CAddress(object):
    def __init__(self, ip="0.0.0.0", port=0):
        self.nServices = 1
        self.nTime = int(time.time())
        self.pchReserved = b"\x00" * 10 + b"\xff" * 2  # ip is 16 bytes on wire to handle v6
        self.ip = ip
        self.port = port

    def deserialize(self, f):
        self.nTime = struct.unpack("<L", f.read(4))[0]
        self.nServices = struct.unpack("<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]

    def serialize(self):
        r = b""
        r += struct.pack("<L", self.nTime)
        r += struct.pack("<Q", self.nServices)
        r += self.pchReserved
        r += socket.inet_aton(self.ip)
        r += struct.pack(">H", self.port)
        return r

    def __repr__(self):
        return "CAddress(nServices=%i ip=%s port=%i time=%d)" % (self.nServices, self.ip, self.port, self.nTime)


class CInv(object):
    MSG_TX = 1
    MSG_BLOCK = 2
    MSG_FILTERED_BLOCK = 3
    MSG_CMPCT_BLOCK = 4
    MSG_XTHINBLOCK = 5
    MSG_THINBLOCK = MSG_CMPCT_BLOCK
    typemap = {
        0: "Error",
        1: "TX",
        2: "Block",
        3: "FilteredBlock",
        4: "CompactBlock",
        5: "XThinBlock",
    }

    def __init__(self, t=0, h=0):
        self.type = t
        self.hash = h

    def deserialize(self, f):
        self.type = struct.unpack("<i", f.read(4))[0]
        self.hash = deser_uint256(f)

    def serialize(self):
        r = b""
        r += struct.pack("<i", self.type)
        r += ser_uint256(self.hash)
        return r

    def __repr__(self):
        return "CInv(type=%s hash=%064x)" \
            % (self.typemap[self.type], self.hash)


class CBlockLocator(object):
    def __init__(self):
        self.nVersion = MY_VERSION
        self.vHave = []

    def deserialize(self, f):
        self.nVersion = struct.unpack("<i", f.read(4))[0]
        self.vHave = deser_uint256_vector(f)

    def serialize(self):
        r = b""
        r += struct.pack("<i", self.nVersion)
        r += ser_uint256_vector(self.vHave)
        return r

    def __repr__(self):
        return "CBlockLocator(nVersion=%i vHave=%s)" \
            % (self.nVersion, repr(self.vHave))


class COutPoint(object):
    def __init__(self, hash=0, n=0):
        if type(hash) is str:
            hash = uint256_from_bigendian(hash)
        if type(hash) is bytes:
            hash = uint256_from_str(hash)
        self.hash = hash
        self.n = n

    def deserialize(self, f):
        self.hash = deser_uint256(f)
        self.n = struct.unpack("<I", f.read(4))[0]

    def serialize(self):
        r = b""
        r += ser_uint256(self.hash)
        r += struct.pack("<I", self.n)
        return r

    def __repr__(self):
        return "COutPoint(hash=%064x n=%i)" % (self.hash, self.n)


class CTxIn(object):
    def __init__(self, outpoint=None, scriptSig=b"", nSequence=0):
        if outpoint is None:
            self.prevout = COutPoint()
        else:
            self.prevout = outpoint
        self.scriptSig = scriptSig
        self.nSequence = nSequence

    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]

    def serialize(self):
        r = b""
        r += self.prevout.serialize()
        r += ser_string(self.scriptSig)
        r += struct.pack("<I", self.nSequence)
        return r

    def __repr__(self):
        return "CTxIn(prevout=%s scriptSig=%s nSequence=%i)" \
            % (repr(self.prevout), hexlify(self.scriptSig),
               self.nSequence)


class CTxOut(object):
    def __init__(self, nValue=0, scriptPubKey=b""):
        self.nValue = nValue
        self.scriptPubKey = scriptPubKey

    def deserialize(self, f):
        self.nValue = struct.unpack("<q", f.read(8))[0]
        self.scriptPubKey = deser_string(f)

    def serialize(self):
        r = b""
        r += struct.pack("<q", int(self.nValue))
        r += ser_string(self.scriptPubKey)
        return r

    def __repr__(self):
        return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" \
            % (self.nValue // COIN, self.nValue % COIN,
               hexlify(self.scriptPubKey))


class CTransaction(object):
    def __init__(self, tx=None):
        if tx is None:
            self.nVersion = 1
            self.vin = []
            self.vout = []
            self.nLockTime = 0
            self.sha256 = None
            self.hash = None
        else:
            self.nVersion = tx.nVersion
            self.vin = copy.deepcopy(tx.vin)
            self.vout = copy.deepcopy(tx.vout)
            self.nLockTime = tx.nLockTime
            self.sha256 = None
            self.hash = None

    def deserialize(self, f):
        if isinstance(f, str):
            # str - assumed to be hex string
            f = BytesIO(unhexlify(f))
        elif isinstance(f, bytes):
            f = BytesIO(f)
        self.nVersion = struct.unpack("<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.sha256 = None
        self.hash = None
        return self

    def serialize(self):
        r = b""
        r += struct.pack("<i", self.nVersion)
        r += ser_vector(self.vin)
        r += ser_vector(self.vout)
        r += struct.pack("<I", self.nLockTime)
        return r

    def toHex(self):
        """Return the hex string serialization of this object"""
        return hexlify(self.serialize()).decode("utf-8")

    def rehash(self):
        self.sha256 = None
        self.calc_sha256()
        return self.hash

    def calc_sha256(self):
        if self.sha256 is None:
            self.sha256 = uint256_from_str(hash256(self.serialize()))
        self.hash = encode(hash256(self.serialize())[::-1], 'hex_codec').decode('ascii')
        return self.hash

    def getHash(self):
        if self.sha256 is None:
            self.rehash()
        return self.sha256

    def is_valid(self):
        self.calc_sha256()
        for tout in self.vout:
            if tout.nValue < 0 or tout.nValue > 21000000 * COIN:
                return False
        return True

    def summary(self):
        self.calc_sha256()
        s = ["Transaction: %064x\n" % self.sha256]
        s.append("%d inputs\n" % len(self.vin))
        for vin in self.vin:
            s.append("  %064x:%d\n" % (vin.prevout.hash, vin.prevout.n))
        s.append("%d outputs\n" % len(self.vout))
        for vout in self.vout:
            s.append("  %12d %s\n" % (vout.nValue, hexlify((vout.scriptPubKey))))
        return "".join(s)

    def __repr__(self):
        return "CTransaction(nVersion=%i vin=%s vout=%s nLockTime=%i)" \
            % (self.nVersion, repr(self.vin), repr(self.vout), self.nLockTime)

    def SignatureHash(self, in_number, scriptCode, nValue, hashcode = SIGHASH_ALL | SIGHASH_FORKID, single = False, debug=False):
        """Calculate hash digest for given input, using SIGHASH_FORKID
        (Bitcoin Cash signing). Returns it in binary, little-endian.

        txin is the corresponding input CTransaction. Supplying it is
        necessary to include the scriptPubKey in the hashed output.

        If single is True, just a single invocation of SHA256 is done,
        instead of the usual, expected double hashing. This is to aid
        applications such as CHECKDATASIG(VERIFY).
        """
        hashdata = struct.pack("<I", self.nVersion)

        h_prevouts = self.hashPrevouts(hashcode)
        if debug:
            print("Hash prevouts:", hexlify(h_prevouts[::-1]))
        hashdata += h_prevouts

        h_sequence = self.hashSequence(hashcode)
        if debug:
            print("Hash sequence:", hexlify(h_sequence[::-1]))

        hashdata += h_sequence
        hashdata += self.vin[in_number].prevout.serialize()


        # FIXME: long scriptPubKeys not supported yet
        assert 75 >= len(scriptCode) > 0
        hashdata += struct.pack("<B", len(scriptCode))
        hashdata += scriptCode
        hashdata += struct.pack("<Q", nValue)
        hashdata += struct.pack("<I", self.vin[in_number].nSequence)

        h_outputs = self.hashOutputs(hashcode, in_number)
        if debug:
            print("Hash outputs:", hexlify(h_outputs[::-1]))
        hashdata += h_outputs
        hashdata += struct.pack("<I", self.nLockTime)
        hashdata += struct.pack("<I", hashcode)

        if debug:
            print("Hash all data:", hexlify(hashdata))
        if single:
            return sha256(hashdata)
        else:
            return hash256(hashdata)

    def hashPrevouts(self, hashcode):
        if hashcode & SIGHASH_ANYONECANPAY:
            return 32 * b"\x00"
        else:
            op_ser = b""
            for inp in self.vin:
                op_ser += inp.prevout.serialize()
            return hash256(op_ser)

    def hashSequence(self, hashcode):
        if (hashcode & SIGHASH_ANYONECANPAY or
            hashcode & 0x1f == SIGHASH_SINGLE or
            hashcode & 0x1f == SIGHASH_NONE):
            return 32 * b"\x00"
        else:
            seq_ser = b""
            for inp in self.vin:
                seq_ser += struct.pack("<I", inp.nSequence)
            return hash256(seq_ser)

    def hashOutputs(self, hashcode, in_number):
        if hashcode & 0x1f == SIGHASH_SINGLE and in_number < len(self.vout):
            return hash256(self.vout[in_number].serialize())
        elif ((not (hashcode & 0x1f == SIGHASH_SINGLE)) and
              (not (hashcode & 0x1f == SIGHASH_NONE))):
            out_ser = b""
            for out in self.vout:
                out_ser += out.serialize()
            return hash256(out_ser)
        else:
            return 32 * b"\x00"

    def SignatureHashLegacy(self, script, inIdx, hashtype):
        """Consensus-correct SignatureHash (legacy variant)

        Returns (hash, err) to precisely match the consensus-critical behavior of
        the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity)
        """
        from .script import FindAndDelete, CScript, OP_CODESEPARATOR

        HASH_ONE = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

        if inIdx >= len(self.vin):
            return (HASH_ONE, "inIdx %d out of range (%d)" % (inIdx, len(self.vin)))

        # create copy as it is going to be modified with FindAndDelete(..)
        txtmp = CTransaction(self)

        for txin in txtmp.vin:
            txin.scriptSig = b''
        txtmp.vin[inIdx].scriptSig = FindAndDelete(script, CScript([OP_CODESEPARATOR]))

        if (hashtype & 0x1f) == SIGHASH_NONE:
            txtmp.vout = []

            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 (HASH_ONE, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout)))

            tmp = txtmp.vout[outIdx]
            txtmp.vout = []
            for i in range(outIdx):
                txtmp.vout.append(CTxOut())
            txtmp.vout.append(tmp)

            for i in range(len(txtmp.vin)):
                if i != inIdx:
                    txtmp.vin[i].nSequence = 0

        if hashtype & SIGHASH_ANYONECANPAY:
            tmp = txtmp.vin[inIdx]
            txtmp.vin = []
            txtmp.vin.append(tmp)

        s = txtmp.serialize()
        s += struct.pack(b"<I", hashtype)

        hash = hash256(s)

        return (hash, None)



class CBlockHeader(object):
    def __init__(self, header=None):
        if header is None:
            self.set_null()
        else:
            self.nVersion = header.nVersion
            self.hashPrevBlock = header.hashPrevBlock
            self.hashMerkleRoot = header.hashMerkleRoot
            self.nTime = header.nTime
            self.nBits = header.nBits
            self.nNonce = header.nNonce
            self.sha256 = header.sha256
            self.hash = header.hash
            self.calc_sha256()

    def set_null(self):
        self.nVersion = 1
        self.hashPrevBlock = 0
        self.hashMerkleRoot = 0
        self.nTime = 0
        self.nBits = 0
        self.nNonce = 0
        self.sha256 = None
        self.hash = None

    def deserialize(self, f):
        self.nVersion = struct.unpack("<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.sha256 = None
        self.hash = None

    def serialize(self):
        r = b""
        r += struct.pack("<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)
        return r

    def calc_sha256(self):
        if self.sha256 is None:
            r = b""
            r += struct.pack("<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)
            self.sha256 = uint256_from_str(hash256(r))
            self.hash = encode(hash256(r)[::-1], 'hex_codec').decode('ascii')
        return self.hash

    def gethashprevblock(self, encoding = 'int'):
        assert encoding == 'hex' or encoding == 'int'
        if encoding == 'int':
            return self.hashPrevBlock
        return hex(self.hashPrevBlock)


    def gethash(self, encoding = 'int'):
        assert encoding == 'hex' or encoding == 'int'
        self.calc_sha256()
        if encoding == 'int':
            return self.sha256
        return hex(self.sha256)

    def rehash(self):
        self.sha256 = None
        self.calc_sha256()
        return self.sha256

    def summary(self):
        s = []
        s.append("Block:  %064x  Time:%s  Version:0x%x Bits:0x%08x\n" %
                 (self.gethash(), time.ctime(self.nTime), self.nVersion, self.nBits))
        s.append("Parent: %064x  Merkle: %064x" % (self.hashPrevBlock, self.hashMerkleRoot))
        return "".join(s)

    def __str__(self):
        return "CBlockHeader(hash=%064x nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)" \
            % (self.gethash(), self.nVersion, self.hashPrevBlock, self.hashMerkleRoot, time.ctime(self.nTime), self.nBits, self.nNonce)

    def __repr__(self):
        return "CBlockHeader(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)" \
            % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
               time.ctime(self.nTime), self.nBits, self.nNonce)


class CBlock(CBlockHeader):
    def __init__(self, header=None):
        super(CBlock, self).__init__(header)
        self.vtx = []

    def deserialize(self, f):
        super(CBlock, self).deserialize(f)
        self.vtx = deser_vector(f, CTransaction)

    def serialize(self):
        r = b""
        r += super(CBlock, self).serialize()
        r += ser_vector(self.vtx)
        return r

    def calc_merkle_root(self):
        hashes = []
        for tx in self.vtx:
            tx.calc_sha256()
            hashes.append(ser_uint256(tx.sha256))
        while len(hashes) > 1:
            newhashes = []
            for i in range(0, len(hashes), 2):
                i2 = min(i + 1, len(hashes) - 1)
                newhashes.append(hash256(hashes[i] + hashes[i2]))
            hashes = newhashes
        if hashes:
            return uint256_from_str(hashes[0])
        return 0

    def is_valid(self):
        self.calc_sha256()
        target = uint256_from_compact(self.nBits)
        if self.sha256 > target:
            return False
        for tx in self.vtx:
            if not tx.is_valid():
                return False
        if self.calc_merkle_root() != self.hashMerkleRoot:
            return False
        return True

    def solve(self):
        self.rehash()
        target = uint256_from_compact(self.nBits)
        while self.sha256 > target:
            self.nNonce += 1
            self.rehash()

    def __str__(self):
        return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx_len=%d)" \
            % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
               time.ctime(self.nTime), self.nBits, self.nNonce, len(self.vtx))

    def __repr__(self):
        return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%s)" \
            % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
               time.ctime(self.nTime), self.nBits, self.nNonce, repr(self.vtx))


class CUnsignedAlert(object):
    def __init__(self):
        self.nVersion = 1
        self.nRelayUntil = 0
        self.nExpiration = 0
        self.nID = 0
        self.nCancel = 0
        self.setCancel = []
        self.nMinVer = 0
        self.nMaxVer = 0
        self.setSubVer = []
        self.nPriority = 0
        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.setCancel = deser_int_vector(f)
        self.nMinVer = struct.unpack("<i", f.read(4))[0]
        self.nMaxVer = struct.unpack("<i", f.read(4))[0]
        self.setSubVer = deser_string_vector(f)
        self.nPriority = struct.unpack("<i", f.read(4))[0]
        self.strComment = deser_string(f)
        self.strStatusBar = deser_string(f)
        self.strReserved = deser_string(f)

    def serialize(self):
        r = b""
        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 += ser_int_vector(self.setCancel)
        r += struct.pack("<i", self.nMinVer)
        r += struct.pack("<i", self.nMaxVer)
        r += ser_string_vector(self.setSubVer)
        r += struct.pack("<i", self.nPriority)
        r += ser_string(self.strComment)
        r += ser_string(self.strStatusBar)
        r += ser_string(self.strReserved)
        return r

    def __repr__(self):
        return "CUnsignedAlert(nVersion %d, nRelayUntil %d, nExpiration %d, nID %d, nCancel %d, nMinVer %d, nMaxVer %d, nPriority %d, strComment %s, strStatusBar %s, strReserved %s)" \
            % (self.nVersion, self.nRelayUntil, self.nExpiration, self.nID,
               self.nCancel, self.nMinVer, self.nMaxVer, self.nPriority,
               self.strComment, self.strStatusBar, self.strReserved)


class CAlert(object):
    def __init__(self):
        self.vchMsg = b""
        self.vchSig = b""

    def deserialize(self, f):
        self.vchMsg = deser_string(f)
        self.vchSig = deser_string(f)

    def serialize(self):
        r = b""
        r += ser_string(self.vchMsg)
        r += ser_string(self.vchSig)
        return r

    def __repr__(self):
        return "CAlert(vchMsg.sz %d, vchSig.sz %d)" \
            % (len(self.vchMsg), len(self.vchSig))


class PrefilledTransaction(object):
    def __init__(self, index=0, tx = None):
        self.index = index
        self.tx = tx

    def deserialize(self, f):
        self.index = deser_compact_size(f)
        self.tx = CTransaction()
        self.tx.deserialize(f)

    def serialize(self):
        r = b""
        r += ser_compact_size(self.index)
        r += self.tx.serialize()
        return r

    def __repr__(self):
        return "PrefilledTransaction(index=%d, tx=%s)" % (self.index, repr(self.tx))

# This is what we send on the wire, in a cmpctblock message.
class P2PHeaderAndShortIDs(object):
    def __init__(self):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids_length = 0
        self.shortids = []
        self.prefilled_txn_length = 0
        self.prefilled_txn = []

    def deserialize(self, f):
        self.header.deserialize(f)
        self.nonce = struct.unpack("<Q", f.read(8))[0]
        self.shortids_length = deser_compact_size(f)
        for i in range(self.shortids_length):
            # shortids are defined to be 6 bytes in the spec, so append
            # two zero bytes and read it in as an 8-byte number
            self.shortids.append(struct.unpack("<Q", f.read(6) + b'\x00\x00')[0])
        self.prefilled_txn = deser_vector(f, PrefilledTransaction)
        self.prefilled_txn_length = len(self.prefilled_txn)

    def serialize(self):
        r = b""
        r += self.header.serialize()
        r += struct.pack("<Q", self.nonce)
        r += ser_compact_size(self.shortids_length)
        for x in self.shortids:
            # We only want the first 6 bytes
            r += struct.pack("<Q", x)[0:6]
        r += ser_vector(self.prefilled_txn)
        return r

    def __repr__(self):
        return "P2PHeaderAndShortIDs(header=%s, nonce=%d, shortids_length=%d, shortids=%s, prefilled_txn_length=%d, prefilledtxn=%s" % (repr(self.header), self.nonce, self.shortids_length, repr(self.shortids), self.prefilled_txn_length, repr(self.prefilled_txn))


# Calculate the BIP 152-compact blocks shortid for a given transaction hash
def calculate_shortid(k0, k1, tx_hash):
    expected_shortid = siphash256(k0, k1, tx_hash)
    expected_shortid &= 0x0000ffffffffffff
    return expected_shortid

# This version gets rid of the array lengths, and reinterprets the differential
# encoding into indices that can be used for lookup.
class HeaderAndShortIDs(object):
    def __init__(self, p2pheaders_and_shortids = None):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids = []
        self.prefilled_txn = []

        if p2pheaders_and_shortids != None:
            self.header = p2pheaders_and_shortids.header
            self.nonce = p2pheaders_and_shortids.nonce
            self.shortids = p2pheaders_and_shortids.shortids
            last_index = -1
            for x in p2pheaders_and_shortids.prefilled_txn:
                self.prefilled_txn.append(PrefilledTransaction(x.index + last_index + 1, x.tx))
                last_index = self.prefilled_txn[-1].index

    def to_p2p(self):
        ret = P2PHeaderAndShortIDs()
        ret.header = self.header
        ret.nonce = self.nonce
        ret.shortids_length = len(self.shortids)
        ret.shortids = self.shortids
        ret.prefilled_txn_length = len(self.prefilled_txn)
        ret.prefilled_txn = []
        last_index = -1
        for x in self.prefilled_txn:
            ret.prefilled_txn.append(PrefilledTransaction(x.index - last_index - 1, x.tx))
            last_index = x.index
        return ret

    def get_siphash_keys(self):
        header_nonce = self.header.serialize()
        header_nonce += struct.pack("<Q", self.nonce)
        hash_header_nonce_as_str = sha256(header_nonce)
        key0 = struct.unpack("<Q", hash_header_nonce_as_str[0:8])[0]
        key1 = struct.unpack("<Q", hash_header_nonce_as_str[8:16])[0]
        return [ key0, key1 ]

    def initialize_from_block(self, block, nonce=0, prefill_list = [0]):
        self.header = CBlockHeader(block)
        self.nonce = nonce
        self.prefilled_txn = [ PrefilledTransaction(i, block.vtx[i]) for i in prefill_list ]
        self.shortids = []
        [k0, k1] = self.get_siphash_keys()
        for i in range(len(block.vtx)):
            if i not in prefill_list:
                self.shortids.append(calculate_shortid(k0, k1, block.vtx[i].sha256))

    def __repr__(self):
        return "HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s" % (repr(self.header), self.nonce, repr(self.shortids), repr(self.prefilled_txn))


class BlockTransactionsRequest(object):

    def __init__(self, blockhash=0, indexes = None):
        self.blockhash = blockhash
        self.indexes = indexes if indexes != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        indexes_length = deser_compact_size(f)
        for i in range(indexes_length):
            self.indexes.append(deser_compact_size(f))

    def serialize(self):
        r = b""
        r += ser_uint256(self.blockhash)
        r += ser_compact_size(len(self.indexes))
        for x in self.indexes:
            r += ser_compact_size(x)
        return r

    # helper to set the differentially encoded indexes from absolute ones
    def from_absolute(self, absolute_indexes):
        self.indexes = []
        last_index = -1
        for x in absolute_indexes:
            self.indexes.append(x-last_index-1)
            last_index = x

    def to_absolute(self):
        absolute_indexes = []
        last_index = -1
        for x in self.indexes:
            absolute_indexes.append(x+last_index+1)
            last_index = absolute_indexes[-1]
        return absolute_indexes

    def __repr__(self):
        return "BlockTransactionsRequest(hash=%064x indexes=%s)" % (self.blockhash, repr(self.indexes))


class BlockTransactions(object):

    def __init__(self, blockhash=0, transactions = None):
        self.blockhash = blockhash
        self.transactions = transactions if transactions != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        self.transactions = deser_vector(f, CTransaction)

    def serialize(self, with_witness=False):
        r = b""
        r += ser_uint256(self.blockhash)
        if with_witness:
            r += ser_vector(self.transactions, "serialize_with_witness")
        else:
            r += ser_vector(self.transactions)
        return r

    def __repr__(self):
        return "BlockTransactions(hash=%064x transactions=%s)" % (self.blockhash, repr(self.transactions))

# Objects that correspond to messages on the wire
class msg_version(object):
    command = b"version"

    def __init__(self):
        self.nVersion = MY_VERSION
        self.nServices = 1
        self.nTime = int(time.time())
        self.addrTo = CAddressInVersion()
        self.addrFrom = CAddressInVersion()
        self.nNonce = random.getrandbits(64)
        self.strSubVer = MY_SUBVERSION
        self.nStartingHeight = -1

    def deserialize(self, f):
        self.nVersion = struct.unpack("<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.addrTo = CAddressInVersion()
        self.addrTo.deserialize(f)
        if self.nVersion >= 106:
            self.addrFrom = CAddressInVersion()
            self.addrFrom.deserialize(f)
            self.nNonce = struct.unpack("<Q", f.read(8))[0]
            self.strSubVer = deser_string(f)
            if self.nVersion >= 209:
                self.nStartingHeight = struct.unpack("<i", f.read(4))[0]
            else:
                self.nStartingHeight = None
        else:
            self.addrFrom = None
            self.nNonce = None
            self.strSubVer = None
            self.nStartingHeight = None

    def serialize(self):
        r = b""
        r += struct.pack("<i", self.nVersion)
        r += struct.pack("<Q", self.nServices)
        r += struct.pack("<q", self.nTime)
        r += self.addrTo.serialize()
        r += self.addrFrom.serialize()
        r += struct.pack("<Q", self.nNonce)
        r += ser_string(self.strSubVer)
        r += struct.pack("<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 = b"verack"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

    def __repr__(self):
        return "msg_verack()"

class msg_extversion(object):
    command = b"extversion"

    def __init__(self, xver = {}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:  # serialize integers in compact format inside the vector
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return "msg_extversion(%s)" % repr(self.xver)

class msg_xupdate(object):
    command = b"xupdate"

    def __init__(self, xver = {}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:  # serialize integers in compact format inside the vector
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return "msg_xupdate(%s)" % repr(self.xver)


class msg_addr(object):
    command = b"addr"

    def __init__(self):
        self.addrs = []

    def deserialize(self, f):
        self.addrs = deser_vector(f, CAddress)

    def serialize(self):
        return ser_vector(self.addrs)

    def __repr__(self):
        return "msg_addr(addrs=%s)" % (repr(self.addrs))


class msg_alert(object):
    command = b"alert"

    def __init__(self):
        self.alert = CAlert()

    def deserialize(self, f):
        self.alert = CAlert()
        self.alert.deserialize(f)

    def serialize(self):
        r = b""
        r += self.alert.serialize()
        return r

    def __repr__(self):
        return "msg_alert(alert=%s)" % (repr(self.alert), )


class msg_inv(object):
    command = b"inv"

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        else:
            self.inv = inv

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return "msg_inv(inv=%s)" % (repr(self.inv))


class msg_getdata(object):
    command = b"getdata"

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        elif type(inv) == list:
            self.inv = inv
        else:
            self.inv = [inv]

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return "msg_getdata(inv=%s)" % (repr(self.inv))


class msg_getblocks(object):
    command = b"getblocks"

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b""
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return "msg_getblocks(locator=%s hashstop=%064x)" \
            % (repr(self.locator), self.hashstop)


class msg_tx(object):
    command = b"tx"

    def __init__(self, tx=CTransaction()):
        self.tx = tx

    def deserialize(self, f):
        self.tx.deserialize(f)

    def serialize(self):
        return self.tx.serialize()

    def __repr__(self):
        return "msg_tx(tx=%s)" % (repr(self.tx))


class msg_block(object):
    command = b"block"

    def __init__(self, block=None):
        if block is None:
            self.block = CBlock()
        else:
            self.block = block

    def deserialize(self, f):
        self.block.deserialize(f)

    def serialize(self):
        return self.block.serialize()

    def __str__(self):
        return "msg_block(block=%s)" % (str(self.block))

    def __repr__(self):
        return "msg_block(block=%s)" % (repr(self.block))


class msg_getaddr(object):
    command = b"getaddr"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

    def __repr__(self):
        return "msg_getaddr()"


class msg_ping(object):
    command = b"ping"

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack("<Q", f.read(8))[0]

    def serialize(self):
        r = b""
        r += struct.pack("<Q", self.nonce)
        return r

    def __repr__(self):
        return "msg_ping(nonce=%08x)" % self.nonce


class msg_pong(object):
    command = b"pong"

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack("<Q", f.read(8))[0]

    def serialize(self):
        r = b""
        r += struct.pack("<Q", self.nonce)
        return r

    def __repr__(self):
        return "msg_pong(nonce=%08x)" % self.nonce


class msg_mempool(object):
    command = b"mempool"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

    def __repr__(self):
        return "msg_mempool()"


class msg_sendheaders(object):
    command = b"sendheaders"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

    def __repr__(self):
        return "msg_sendheaders()"



class msg_getheaders(object):
    """
    getheaders message has
    locator: CBlockLocator object that identifies what block to start with
    hash_stop: hash of last desired block header, 0 to get as many as possible
    """
    command = b"getheaders"

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b""
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return "msg_getheaders(locator=%s, stop=%064x)" \
            % (repr(self.locator), self.hashstop)


class msg_headers(object):
    """
    headers message has
    <count> <vector of block headers>
    """
    command = b"headers"

    def __init__(self, headers = None):
        self.headers = [] if headers is None else headers

    def deserialize(self, f):
        # comment in bitcoind indicates these should be deserialized as blocks
        blocks = deser_vector(f, CBlock)
        for x in blocks:
            self.headers.append(CBlockHeader(x))

    def serialize(self):
        blocks = [CBlock(x) for x in self.headers]
        return ser_vector(blocks)

    def __repr__(self):
        return "msg_headers(headers=%s)" % repr(self.headers)


class msg_reject(object):
    command = b"reject"
    REJECT_MALFORMED = 1

    def __init__(self):
        self.message = b""
        self.code = 0
        self.reason = b""
        self.data = 0

    def deserialize(self, f):
        self.message = deser_string(f)
        self.code = struct.unpack("<B", f.read(1))[0]
        self.reason = deser_string(f)
        if (self.code != self.REJECT_MALFORMED and
                (self.message == b"block" or self.message == b"tx")):
            self.data = deser_uint256(f)

    def serialize(self):
        r = ser_string(self.message)
        r += struct.pack("<B", self.code)
        r += ser_string(self.reason)
        if (self.code != self.REJECT_MALFORMED and
                (self.message == b"block" or self.message == b"tx")):
            r += ser_uint256(self.data)
        return r

    def __repr__(self):
        return "msg_reject: %s %d %s [%064x]" \
            % (self.message, self.code, self.reason, self.data)

class msg_sendcmpct(object):
    command = b"sendcmpct"

    def __init__(self):
        self.announce = False
        self.version = 1

    def deserialize(self, f):
        self.announce = struct.unpack("<?", f.read(1))[0]
        self.version = struct.unpack("<Q", f.read(8))[0]

    def serialize(self):
        r = b""
        r += struct.pack("<?", self.announce)
        r += struct.pack("<Q", self.version)
        return r

    def __repr__(self):
        return "msg_sendcmpct(announce=%s, version=%lu)" % (self.announce, self.version)

class msg_cmpctblock(object):
    command = b"cmpctblock"

    def __init__(self, header_and_shortids = None):
        self.header_and_shortids = header_and_shortids

    def deserialize(self, f):
        self.header_and_shortids = P2PHeaderAndShortIDs()
        self.header_and_shortids.deserialize(f)

    def serialize(self):
        r = b""
        r += self.header_and_shortids.serialize()
        return r

    def __repr__(self):
        return "msg_cmpctblock(HeaderAndShortIDs=%s)" % repr(self.header_and_shortids)

class msg_getblocktxn(object):
    command = b"getblocktxn"

    def __init__(self):
        self.block_txn_request = None

    def deserialize(self, f):
        self.block_txn_request = BlockTransactionsRequest()
        self.block_txn_request.deserialize(f)

    def serialize(self):
        r = b""
        r += self.block_txn_request.serialize()
        return r

    def __repr__(self):
        return "msg_getblocktxn(block_txn_request=%s)" % (repr(self.block_txn_request))

class msg_blocktxn(object):
    command = b"blocktxn"

    def __init__(self):
        self.block_transactions = BlockTransactions()

    def deserialize(self, f):
        self.block_transactions.deserialize(f)

    def serialize(self):
        r = b""
        r += self.block_transactions.serialize()
        return r

    def __repr__(self):
        return "msg_blocktxn(block_transactions=%s)" % (repr(self.block_transactions))


def Test():
    import doctest
    import sys
    print(doctest.testmod(sys.modules[__name__],verbose=True))

## py.test code
def testCTransactionCopyConstruct():
    a = CTransaction()
    b = CTransaction(a)

607d1ef18a8532982277d8b03117b95f1a7490a3
<mask token>


class P2PHeaderAndShortIDs(object):

    def __init__(self):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids_length = 0
        self.shortids = []
        self.prefilled_txn_length = 0
        self.prefilled_txn = []

    def deserialize(self, f):
        self.header.deserialize(f)
        self.nonce = struct.unpack('<Q', f.read(8))[0]
        self.shortids_length = deser_compact_size(f)
        for i in range(self.shortids_length):
            self.shortids.append(struct.unpack('<Q', f.read(6) +
                b'\x00\x00')[0])
        self.prefilled_txn = deser_vector(f, PrefilledTransaction)
        self.prefilled_txn_length = len(self.prefilled_txn)

    def serialize(self):
        r = b''
        r += self.header.serialize()
        r += struct.pack('<Q', self.nonce)
        r += ser_compact_size(self.shortids_length)
        for x in self.shortids:
            r += struct.pack('<Q', x)[0:6]
        r += ser_vector(self.prefilled_txn)
        return r

    def __repr__(self):
        return (
            'P2PHeaderAndShortIDs(header=%s, nonce=%d, shortids_length=%d, shortids=%s, prefilled_txn_length=%d, prefilledtxn=%s'
             % (repr(self.header), self.nonce, self.shortids_length, repr(
            self.shortids), self.prefilled_txn_length, repr(self.
            prefilled_txn)))


<mask token>


class HeaderAndShortIDs(object):

    def __init__(self, p2pheaders_and_shortids=None):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids = []
        self.prefilled_txn = []
        if p2pheaders_and_shortids != None:
            self.header = p2pheaders_and_shortids.header
            self.nonce = p2pheaders_and_shortids.nonce
            self.shortids = p2pheaders_and_shortids.shortids
            last_index = -1
            for x in p2pheaders_and_shortids.prefilled_txn:
                self.prefilled_txn.append(PrefilledTransaction(x.index +
                    last_index + 1, x.tx))
                last_index = self.prefilled_txn[-1].index

    def to_p2p(self):
        ret = P2PHeaderAndShortIDs()
        ret.header = self.header
        ret.nonce = self.nonce
        ret.shortids_length = len(self.shortids)
        ret.shortids = self.shortids
        ret.prefilled_txn_length = len(self.prefilled_txn)
        ret.prefilled_txn = []
        last_index = -1
        for x in self.prefilled_txn:
            ret.prefilled_txn.append(PrefilledTransaction(x.index -
                last_index - 1, x.tx))
            last_index = x.index
        return ret

    def get_siphash_keys(self):
        header_nonce = self.header.serialize()
        header_nonce += struct.pack('<Q', self.nonce)
        hash_header_nonce_as_str = sha256(header_nonce)
        key0 = struct.unpack('<Q', hash_header_nonce_as_str[0:8])[0]
        key1 = struct.unpack('<Q', hash_header_nonce_as_str[8:16])[0]
        return [key0, key1]

    def initialize_from_block(self, block, nonce=0, prefill_list=[0]):
        self.header = CBlockHeader(block)
        self.nonce = nonce
        self.prefilled_txn = [PrefilledTransaction(i, block.vtx[i]) for i in
            prefill_list]
        self.shortids = []
        [k0, k1] = self.get_siphash_keys()
        for i in range(len(block.vtx)):
            if i not in prefill_list:
                self.shortids.append(calculate_shortid(k0, k1, block.vtx[i]
                    .sha256))

    def __repr__(self):
        return (
            'HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s'
             % (repr(self.header), self.nonce, repr(self.shortids), repr(
            self.prefilled_txn)))


class BlockTransactionsRequest(object):

    def __init__(self, blockhash=0, indexes=None):
        self.blockhash = blockhash
        self.indexes = indexes if indexes != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        indexes_length = deser_compact_size(f)
        for i in range(indexes_length):
            self.indexes.append(deser_compact_size(f))

    def serialize(self):
        r = b''
        r += ser_uint256(self.blockhash)
        r += ser_compact_size(len(self.indexes))
        for x in self.indexes:
            r += ser_compact_size(x)
        return r

    def from_absolute(self, absolute_indexes):
        self.indexes = []
        last_index = -1
        for x in absolute_indexes:
            self.indexes.append(x - last_index - 1)
            last_index = x

    def to_absolute(self):
        absolute_indexes = []
        last_index = -1
        for x in self.indexes:
            absolute_indexes.append(x + last_index + 1)
            last_index = absolute_indexes[-1]
        return absolute_indexes

    def __repr__(self):
        return 'BlockTransactionsRequest(hash=%064x indexes=%s)' % (self.
            blockhash, repr(self.indexes))


class BlockTransactions(object):

    def __init__(self, blockhash=0, transactions=None):
        self.blockhash = blockhash
        self.transactions = transactions if transactions != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        self.transactions = deser_vector(f, CTransaction)

    def serialize(self, with_witness=False):
        r = b''
        r += ser_uint256(self.blockhash)
        if with_witness:
            r += ser_vector(self.transactions, 'serialize_with_witness')
        else:
            r += ser_vector(self.transactions)
        return r

    def __repr__(self):
        return 'BlockTransactions(hash=%064x transactions=%s)' % (self.
            blockhash, repr(self.transactions))


class msg_version(object):
    command = b'version'

    def __init__(self):
        self.nVersion = MY_VERSION
        self.nServices = 1
        self.nTime = int(time.time())
        self.addrTo = CAddressInVersion()
        self.addrFrom = CAddressInVersion()
        self.nNonce = random.getrandbits(64)
        self.strSubVer = MY_SUBVERSION
        self.nStartingHeight = -1

    def deserialize(self, f):
        self.nVersion = struct.unpack('<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.addrTo = CAddressInVersion()
        self.addrTo.deserialize(f)
        if self.nVersion >= 106:
            self.addrFrom = CAddressInVersion()
            self.addrFrom.deserialize(f)
            self.nNonce = struct.unpack('<Q', f.read(8))[0]
            self.strSubVer = deser_string(f)
            if self.nVersion >= 209:
                self.nStartingHeight = struct.unpack('<i', f.read(4))[0]
            else:
                self.nStartingHeight = None
        else:
            self.addrFrom = None
            self.nNonce = None
            self.strSubVer = None
            self.nStartingHeight = None

    def serialize(self):
        r = b''
        r += struct.pack('<i', self.nVersion)
        r += struct.pack('<Q', self.nServices)
        r += struct.pack('<q', self.nTime)
        r += self.addrTo.serialize()
        r += self.addrFrom.serialize()
        r += struct.pack('<Q', self.nNonce)
        r += ser_string(self.strSubVer)
        r += struct.pack('<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 = b'verack'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_verack()'


class msg_extversion(object):
    command = b'extversion'

    def __init__(self, xver={}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return 'msg_extversion(%s)' % repr(self.xver)


class msg_xupdate(object):
    command = b'xupdate'

    def __init__(self, xver={}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return 'msg_xupdate(%s)' % repr(self.xver)


class msg_addr(object):
    command = b'addr'

    def __init__(self):
        self.addrs = []

    def deserialize(self, f):
        self.addrs = deser_vector(f, CAddress)

    def serialize(self):
        return ser_vector(self.addrs)

    def __repr__(self):
        return 'msg_addr(addrs=%s)' % repr(self.addrs)


class msg_alert(object):
    command = b'alert'

    def __init__(self):
        self.alert = CAlert()

    def deserialize(self, f):
        self.alert = CAlert()
        self.alert.deserialize(f)

    def serialize(self):
        r = b''
        r += self.alert.serialize()
        return r

    def __repr__(self):
        return 'msg_alert(alert=%s)' % (repr(self.alert),)


class msg_inv(object):
    command = b'inv'

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        else:
            self.inv = inv

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return 'msg_inv(inv=%s)' % repr(self.inv)


class msg_getdata(object):
    command = b'getdata'

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        elif type(inv) == list:
            self.inv = inv
        else:
            self.inv = [inv]

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return 'msg_getdata(inv=%s)' % repr(self.inv)


class msg_getblocks(object):
    command = b'getblocks'

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b''
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return 'msg_getblocks(locator=%s hashstop=%064x)' % (repr(self.
            locator), self.hashstop)


class msg_tx(object):
    command = b'tx'

    def __init__(self, tx=CTransaction()):
        self.tx = tx

    def deserialize(self, f):
        self.tx.deserialize(f)

    def serialize(self):
        return self.tx.serialize()

    def __repr__(self):
        return 'msg_tx(tx=%s)' % repr(self.tx)


class msg_block(object):
    command = b'block'

    def __init__(self, block=None):
        if block is None:
            self.block = CBlock()
        else:
            self.block = block

    def deserialize(self, f):
        self.block.deserialize(f)

    def serialize(self):
        return self.block.serialize()

    def __str__(self):
        return 'msg_block(block=%s)' % str(self.block)

    def __repr__(self):
        return 'msg_block(block=%s)' % repr(self.block)


class msg_getaddr(object):
    command = b'getaddr'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_getaddr()'


class msg_ping(object):
    command = b'ping'

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nonce)
        return r

    def __repr__(self):
        return 'msg_ping(nonce=%08x)' % self.nonce


class msg_pong(object):
    command = b'pong'

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nonce)
        return r

    def __repr__(self):
        return 'msg_pong(nonce=%08x)' % self.nonce


class msg_mempool(object):
    command = b'mempool'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_mempool()'


class msg_sendheaders(object):
    command = b'sendheaders'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_sendheaders()'


class msg_getheaders(object):
    """
    getheaders message has
    locator: CBlockLocator object that identifies what block to start with
    hash_stop: hash of last desired block header, 0 to get as many as possible
    """
    command = b'getheaders'

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b''
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return 'msg_getheaders(locator=%s, stop=%064x)' % (repr(self.
            locator), self.hashstop)


class msg_headers(object):
    """
    headers message has
    <count> <vector of block headers>
    """
    command = b'headers'

    def __init__(self, headers=None):
        self.headers = [] if headers is None else headers

    def deserialize(self, f):
        blocks = deser_vector(f, CBlock)
        for x in blocks:
            self.headers.append(CBlockHeader(x))

    def serialize(self):
        blocks = [CBlock(x) for x in self.headers]
        return ser_vector(blocks)

    def __repr__(self):
        return 'msg_headers(headers=%s)' % repr(self.headers)


class msg_reject(object):
    command = b'reject'
    REJECT_MALFORMED = 1

    def __init__(self):
        self.message = b''
        self.code = 0
        self.reason = b''
        self.data = 0

    def deserialize(self, f):
        self.message = deser_string(f)
        self.code = struct.unpack('<B', f.read(1))[0]
        self.reason = deser_string(f)
        if self.code != self.REJECT_MALFORMED and (self.message == b'block' or
            self.message == b'tx'):
            self.data = deser_uint256(f)

    def serialize(self):
        r = ser_string(self.message)
        r += struct.pack('<B', self.code)
        r += ser_string(self.reason)
        if self.code != self.REJECT_MALFORMED and (self.message == b'block' or
            self.message == b'tx'):
            r += ser_uint256(self.data)
        return r

    def __repr__(self):
        return 'msg_reject: %s %d %s [%064x]' % (self.message, self.code,
            self.reason, self.data)


class msg_sendcmpct(object):
    command = b'sendcmpct'

    def __init__(self):
        self.announce = False
        self.version = 1

    def deserialize(self, f):
        self.announce = struct.unpack('<?', f.read(1))[0]
        self.version = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<?', self.announce)
        r += struct.pack('<Q', self.version)
        return r

    def __repr__(self):
        return 'msg_sendcmpct(announce=%s, version=%lu)' % (self.announce,
            self.version)


class msg_cmpctblock(object):
    command = b'cmpctblock'

    def __init__(self, header_and_shortids=None):
        self.header_and_shortids = header_and_shortids

    def deserialize(self, f):
        self.header_and_shortids = P2PHeaderAndShortIDs()
        self.header_and_shortids.deserialize(f)

    def serialize(self):
        r = b''
        r += self.header_and_shortids.serialize()
        return r

    def __repr__(self):
        return 'msg_cmpctblock(HeaderAndShortIDs=%s)' % repr(self.
            header_and_shortids)


class msg_getblocktxn(object):
    command = b'getblocktxn'

    def __init__(self):
        self.block_txn_request = None

    def deserialize(self, f):
        self.block_txn_request = BlockTransactionsRequest()
        self.block_txn_request.deserialize(f)

    def serialize(self):
        r = b''
        r += self.block_txn_request.serialize()
        return r

    def __repr__(self):
        return 'msg_getblocktxn(block_txn_request=%s)' % repr(self.
            block_txn_request)


class msg_blocktxn(object):
    command = b'blocktxn'

    def __init__(self):
        self.block_transactions = BlockTransactions()

    def deserialize(self, f):
        self.block_transactions.deserialize(f)

    def serialize(self):
        r = b''
        r += self.block_transactions.serialize()
        return r

    def __repr__(self):
        return 'msg_blocktxn(block_transactions=%s)' % repr(self.
            block_transactions)


<mask token>

<mask token>


class CUnsignedAlert(object):

    def __init__(self):
        self.nVersion = 1
        self.nRelayUntil = 0
        self.nExpiration = 0
        self.nID = 0
        self.nCancel = 0
        self.setCancel = []
        self.nMinVer = 0
        self.nMaxVer = 0
        self.setSubVer = []
        self.nPriority = 0
        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.setCancel = deser_int_vector(f)
        self.nMinVer = struct.unpack('<i', f.read(4))[0]
        self.nMaxVer = struct.unpack('<i', f.read(4))[0]
        self.setSubVer = deser_string_vector(f)
        self.nPriority = struct.unpack('<i', f.read(4))[0]
        self.strComment = deser_string(f)
        self.strStatusBar = deser_string(f)
        self.strReserved = deser_string(f)

    def serialize(self):
        r = b''
        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 += ser_int_vector(self.setCancel)
        r += struct.pack('<i', self.nMinVer)
        r += struct.pack('<i', self.nMaxVer)
        r += ser_string_vector(self.setSubVer)
        r += struct.pack('<i', self.nPriority)
        r += ser_string(self.strComment)
        r += ser_string(self.strStatusBar)
        r += ser_string(self.strReserved)
        return r

    def __repr__(self):
        return (
            'CUnsignedAlert(nVersion %d, nRelayUntil %d, nExpiration %d, nID %d, nCancel %d, nMinVer %d, nMaxVer %d, nPriority %d, strComment %s, strStatusBar %s, strReserved %s)'
             % (self.nVersion, self.nRelayUntil, self.nExpiration, self.nID,
            self.nCancel, self.nMinVer, self.nMaxVer, self.nPriority, self.
            strComment, self.strStatusBar, self.strReserved))


class CAlert(object):

    def __init__(self):
        self.vchMsg = b''
        self.vchSig = b''

    def deserialize(self, f):
        self.vchMsg = deser_string(f)
        self.vchSig = deser_string(f)

    def serialize(self):
        r = b''
        r += ser_string(self.vchMsg)
        r += ser_string(self.vchSig)
        return r

    def __repr__(self):
        return 'CAlert(vchMsg.sz %d, vchSig.sz %d)' % (len(self.vchMsg),
            len(self.vchSig))


class PrefilledTransaction(object):

    def __init__(self, index=0, tx=None):
        self.index = index
        self.tx = tx

    def deserialize(self, f):
        self.index = deser_compact_size(f)
        self.tx = CTransaction()
        self.tx.deserialize(f)

    def serialize(self):
        r = b''
        r += ser_compact_size(self.index)
        r += self.tx.serialize()
        return r

    def __repr__(self):
        return 'PrefilledTransaction(index=%d, tx=%s)' % (self.index, repr(
            self.tx))


class P2PHeaderAndShortIDs(object):

    def __init__(self):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids_length = 0
        self.shortids = []
        self.prefilled_txn_length = 0
        self.prefilled_txn = []

    def deserialize(self, f):
        self.header.deserialize(f)
        self.nonce = struct.unpack('<Q', f.read(8))[0]
        self.shortids_length = deser_compact_size(f)
        for i in range(self.shortids_length):
            self.shortids.append(struct.unpack('<Q', f.read(6) +
                b'\x00\x00')[0])
        self.prefilled_txn = deser_vector(f, PrefilledTransaction)
        self.prefilled_txn_length = len(self.prefilled_txn)

    def serialize(self):
        r = b''
        r += self.header.serialize()
        r += struct.pack('<Q', self.nonce)
        r += ser_compact_size(self.shortids_length)
        for x in self.shortids:
            r += struct.pack('<Q', x)[0:6]
        r += ser_vector(self.prefilled_txn)
        return r

    def __repr__(self):
        return (
            'P2PHeaderAndShortIDs(header=%s, nonce=%d, shortids_length=%d, shortids=%s, prefilled_txn_length=%d, prefilledtxn=%s'
             % (repr(self.header), self.nonce, self.shortids_length, repr(
            self.shortids), self.prefilled_txn_length, repr(self.
            prefilled_txn)))


<mask token>


class HeaderAndShortIDs(object):

    def __init__(self, p2pheaders_and_shortids=None):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids = []
        self.prefilled_txn = []
        if p2pheaders_and_shortids != None:
            self.header = p2pheaders_and_shortids.header
            self.nonce = p2pheaders_and_shortids.nonce
            self.shortids = p2pheaders_and_shortids.shortids
            last_index = -1
            for x in p2pheaders_and_shortids.prefilled_txn:
                self.prefilled_txn.append(PrefilledTransaction(x.index +
                    last_index + 1, x.tx))
                last_index = self.prefilled_txn[-1].index

    def to_p2p(self):
        ret = P2PHeaderAndShortIDs()
        ret.header = self.header
        ret.nonce = self.nonce
        ret.shortids_length = len(self.shortids)
        ret.shortids = self.shortids
        ret.prefilled_txn_length = len(self.prefilled_txn)
        ret.prefilled_txn = []
        last_index = -1
        for x in self.prefilled_txn:
            ret.prefilled_txn.append(PrefilledTransaction(x.index -
                last_index - 1, x.tx))
            last_index = x.index
        return ret

    def get_siphash_keys(self):
        header_nonce = self.header.serialize()
        header_nonce += struct.pack('<Q', self.nonce)
        hash_header_nonce_as_str = sha256(header_nonce)
        key0 = struct.unpack('<Q', hash_header_nonce_as_str[0:8])[0]
        key1 = struct.unpack('<Q', hash_header_nonce_as_str[8:16])[0]
        return [key0, key1]

    def initialize_from_block(self, block, nonce=0, prefill_list=[0]):
        self.header = CBlockHeader(block)
        self.nonce = nonce
        self.prefilled_txn = [PrefilledTransaction(i, block.vtx[i]) for i in
            prefill_list]
        self.shortids = []
        [k0, k1] = self.get_siphash_keys()
        for i in range(len(block.vtx)):
            if i not in prefill_list:
                self.shortids.append(calculate_shortid(k0, k1, block.vtx[i]
                    .sha256))

    def __repr__(self):
        return (
            'HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s'
             % (repr(self.header), self.nonce, repr(self.shortids), repr(
            self.prefilled_txn)))


class BlockTransactionsRequest(object):

    def __init__(self, blockhash=0, indexes=None):
        self.blockhash = blockhash
        self.indexes = indexes if indexes != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        indexes_length = deser_compact_size(f)
        for i in range(indexes_length):
            self.indexes.append(deser_compact_size(f))

    def serialize(self):
        r = b''
        r += ser_uint256(self.blockhash)
        r += ser_compact_size(len(self.indexes))
        for x in self.indexes:
            r += ser_compact_size(x)
        return r

    def from_absolute(self, absolute_indexes):
        self.indexes = []
        last_index = -1
        for x in absolute_indexes:
            self.indexes.append(x - last_index - 1)
            last_index = x

    def to_absolute(self):
        absolute_indexes = []
        last_index = -1
        for x in self.indexes:
            absolute_indexes.append(x + last_index + 1)
            last_index = absolute_indexes[-1]
        return absolute_indexes

    def __repr__(self):
        return 'BlockTransactionsRequest(hash=%064x indexes=%s)' % (self.
            blockhash, repr(self.indexes))


class BlockTransactions(object):

    def __init__(self, blockhash=0, transactions=None):
        self.blockhash = blockhash
        self.transactions = transactions if transactions != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        self.transactions = deser_vector(f, CTransaction)

    def serialize(self, with_witness=False):
        r = b''
        r += ser_uint256(self.blockhash)
        if with_witness:
            r += ser_vector(self.transactions, 'serialize_with_witness')
        else:
            r += ser_vector(self.transactions)
        return r

    def __repr__(self):
        return 'BlockTransactions(hash=%064x transactions=%s)' % (self.
            blockhash, repr(self.transactions))


class msg_version(object):
    command = b'version'

    def __init__(self):
        self.nVersion = MY_VERSION
        self.nServices = 1
        self.nTime = int(time.time())
        self.addrTo = CAddressInVersion()
        self.addrFrom = CAddressInVersion()
        self.nNonce = random.getrandbits(64)
        self.strSubVer = MY_SUBVERSION
        self.nStartingHeight = -1

    def deserialize(self, f):
        self.nVersion = struct.unpack('<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.addrTo = CAddressInVersion()
        self.addrTo.deserialize(f)
        if self.nVersion >= 106:
            self.addrFrom = CAddressInVersion()
            self.addrFrom.deserialize(f)
            self.nNonce = struct.unpack('<Q', f.read(8))[0]
            self.strSubVer = deser_string(f)
            if self.nVersion >= 209:
                self.nStartingHeight = struct.unpack('<i', f.read(4))[0]
            else:
                self.nStartingHeight = None
        else:
            self.addrFrom = None
            self.nNonce = None
            self.strSubVer = None
            self.nStartingHeight = None

    def serialize(self):
        r = b''
        r += struct.pack('<i', self.nVersion)
        r += struct.pack('<Q', self.nServices)
        r += struct.pack('<q', self.nTime)
        r += self.addrTo.serialize()
        r += self.addrFrom.serialize()
        r += struct.pack('<Q', self.nNonce)
        r += ser_string(self.strSubVer)
        r += struct.pack('<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 = b'verack'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_verack()'


class msg_extversion(object):
    command = b'extversion'

    def __init__(self, xver={}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return 'msg_extversion(%s)' % repr(self.xver)


class msg_xupdate(object):
    command = b'xupdate'

    def __init__(self, xver={}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return 'msg_xupdate(%s)' % repr(self.xver)


class msg_addr(object):
    command = b'addr'

    def __init__(self):
        self.addrs = []

    def deserialize(self, f):
        self.addrs = deser_vector(f, CAddress)

    def serialize(self):
        return ser_vector(self.addrs)

    def __repr__(self):
        return 'msg_addr(addrs=%s)' % repr(self.addrs)


class msg_alert(object):
    command = b'alert'

    def __init__(self):
        self.alert = CAlert()

    def deserialize(self, f):
        self.alert = CAlert()
        self.alert.deserialize(f)

    def serialize(self):
        r = b''
        r += self.alert.serialize()
        return r

    def __repr__(self):
        return 'msg_alert(alert=%s)' % (repr(self.alert),)


class msg_inv(object):
    command = b'inv'

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        else:
            self.inv = inv

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return 'msg_inv(inv=%s)' % repr(self.inv)


class msg_getdata(object):
    command = b'getdata'

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        elif type(inv) == list:
            self.inv = inv
        else:
            self.inv = [inv]

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return 'msg_getdata(inv=%s)' % repr(self.inv)


class msg_getblocks(object):
    command = b'getblocks'

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b''
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return 'msg_getblocks(locator=%s hashstop=%064x)' % (repr(self.
            locator), self.hashstop)


class msg_tx(object):
    command = b'tx'

    def __init__(self, tx=CTransaction()):
        self.tx = tx

    def deserialize(self, f):
        self.tx.deserialize(f)

    def serialize(self):
        return self.tx.serialize()

    def __repr__(self):
        return 'msg_tx(tx=%s)' % repr(self.tx)


class msg_block(object):
    command = b'block'

    def __init__(self, block=None):
        if block is None:
            self.block = CBlock()
        else:
            self.block = block

    def deserialize(self, f):
        self.block.deserialize(f)

    def serialize(self):
        return self.block.serialize()

    def __str__(self):
        return 'msg_block(block=%s)' % str(self.block)

    def __repr__(self):
        return 'msg_block(block=%s)' % repr(self.block)


class msg_getaddr(object):
    command = b'getaddr'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_getaddr()'


class msg_ping(object):
    command = b'ping'

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nonce)
        return r

    def __repr__(self):
        return 'msg_ping(nonce=%08x)' % self.nonce


class msg_pong(object):
    command = b'pong'

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nonce)
        return r

    def __repr__(self):
        return 'msg_pong(nonce=%08x)' % self.nonce


class msg_mempool(object):
    command = b'mempool'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_mempool()'


class msg_sendheaders(object):
    command = b'sendheaders'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_sendheaders()'


class msg_getheaders(object):
    """
    getheaders message has
    locator: CBlockLocator object that identifies what block to start with
    hash_stop: hash of last desired block header, 0 to get as many as possible
    """
    command = b'getheaders'

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b''
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return 'msg_getheaders(locator=%s, stop=%064x)' % (repr(self.
            locator), self.hashstop)


class msg_headers(object):
    """
    headers message has
    <count> <vector of block headers>
    """
    command = b'headers'

    def __init__(self, headers=None):
        self.headers = [] if headers is None else headers

    def deserialize(self, f):
        blocks = deser_vector(f, CBlock)
        for x in blocks:
            self.headers.append(CBlockHeader(x))

    def serialize(self):
        blocks = [CBlock(x) for x in self.headers]
        return ser_vector(blocks)

    def __repr__(self):
        return 'msg_headers(headers=%s)' % repr(self.headers)


class msg_reject(object):
    command = b'reject'
    REJECT_MALFORMED = 1

    def __init__(self):
        self.message = b''
        self.code = 0
        self.reason = b''
        self.data = 0

    def deserialize(self, f):
        self.message = deser_string(f)
        self.code = struct.unpack('<B', f.read(1))[0]
        self.reason = deser_string(f)
        if self.code != self.REJECT_MALFORMED and (self.message == b'block' or
            self.message == b'tx'):
            self.data = deser_uint256(f)

    def serialize(self):
        r = ser_string(self.message)
        r += struct.pack('<B', self.code)
        r += ser_string(self.reason)
        if self.code != self.REJECT_MALFORMED and (self.message == b'block' or
            self.message == b'tx'):
            r += ser_uint256(self.data)
        return r

    def __repr__(self):
        return 'msg_reject: %s %d %s [%064x]' % (self.message, self.code,
            self.reason, self.data)


class msg_sendcmpct(object):
    command = b'sendcmpct'

    def __init__(self):
        self.announce = False
        self.version = 1

    def deserialize(self, f):
        self.announce = struct.unpack('<?', f.read(1))[0]
        self.version = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<?', self.announce)
        r += struct.pack('<Q', self.version)
        return r

    def __repr__(self):
        return 'msg_sendcmpct(announce=%s, version=%lu)' % (self.announce,
            self.version)


class msg_cmpctblock(object):
    command = b'cmpctblock'

    def __init__(self, header_and_shortids=None):
        self.header_and_shortids = header_and_shortids

    def deserialize(self, f):
        self.header_and_shortids = P2PHeaderAndShortIDs()
        self.header_and_shortids.deserialize(f)

    def serialize(self):
        r = b''
        r += self.header_and_shortids.serialize()
        return r

    def __repr__(self):
        return 'msg_cmpctblock(HeaderAndShortIDs=%s)' % repr(self.
            header_and_shortids)


class msg_getblocktxn(object):
    command = b'getblocktxn'

    def __init__(self):
        self.block_txn_request = None

    def deserialize(self, f):
        self.block_txn_request = BlockTransactionsRequest()
        self.block_txn_request.deserialize(f)

    def serialize(self):
        r = b''
        r += self.block_txn_request.serialize()
        return r

    def __repr__(self):
        return 'msg_getblocktxn(block_txn_request=%s)' % repr(self.
            block_txn_request)


class msg_blocktxn(object):
    command = b'blocktxn'

    def __init__(self):
        self.block_transactions = BlockTransactions()

    def deserialize(self, f):
        self.block_transactions.deserialize(f)

    def serialize(self):
        r = b''
        r += self.block_transactions.serialize()
        return r

    def __repr__(self):
        return 'msg_blocktxn(block_transactions=%s)' % repr(self.
            block_transactions)


<mask token>

<mask token>


class CBlockHeader(object):

    def __init__(self, header=None):
        if header is None:
            self.set_null()
        else:
            self.nVersion = header.nVersion
            self.hashPrevBlock = header.hashPrevBlock
            self.hashMerkleRoot = header.hashMerkleRoot
            self.nTime = header.nTime
            self.nBits = header.nBits
            self.nNonce = header.nNonce
            self.sha256 = header.sha256
            self.hash = header.hash
            self.calc_sha256()
    <mask token>
    <mask token>
    <mask token>
    <mask token>

    def gethashprevblock(self, encoding='int'):
        assert encoding == 'hex' or encoding == 'int'
        if encoding == 'int':
            return self.hashPrevBlock
        return hex(self.hashPrevBlock)

    def gethash(self, encoding='int'):
        assert encoding == 'hex' or encoding == 'int'
        self.calc_sha256()
        if encoding == 'int':
            return self.sha256
        return hex(self.sha256)

    def rehash(self):
        self.sha256 = None
        self.calc_sha256()
        return self.sha256
    <mask token>
    <mask token>

    def __repr__(self):
        return (
            'CBlockHeader(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)'
             % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
            time.ctime(self.nTime), self.nBits, self.nNonce))


class CBlock(CBlockHeader):

    def __init__(self, header=None):
        super(CBlock, self).__init__(header)
        self.vtx = []

    def deserialize(self, f):
        super(CBlock, self).deserialize(f)
        self.vtx = deser_vector(f, CTransaction)

    def serialize(self):
        r = b''
        r += super(CBlock, self).serialize()
        r += ser_vector(self.vtx)
        return r

    def calc_merkle_root(self):
        hashes = []
        for tx in self.vtx:
            tx.calc_sha256()
            hashes.append(ser_uint256(tx.sha256))
        while len(hashes) > 1:
            newhashes = []
            for i in range(0, len(hashes), 2):
                i2 = min(i + 1, len(hashes) - 1)
                newhashes.append(hash256(hashes[i] + hashes[i2]))
            hashes = newhashes
        if hashes:
            return uint256_from_str(hashes[0])
        return 0

    def is_valid(self):
        self.calc_sha256()
        target = uint256_from_compact(self.nBits)
        if self.sha256 > target:
            return False
        for tx in self.vtx:
            if not tx.is_valid():
                return False
        if self.calc_merkle_root() != self.hashMerkleRoot:
            return False
        return True

    def solve(self):
        self.rehash()
        target = uint256_from_compact(self.nBits)
        while self.sha256 > target:
            self.nNonce += 1
            self.rehash()

    def __str__(self):
        return (
            'CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx_len=%d)'
             % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
            time.ctime(self.nTime), self.nBits, self.nNonce, len(self.vtx)))

    def __repr__(self):
        return (
            'CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%s)'
             % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
            time.ctime(self.nTime), self.nBits, self.nNonce, repr(self.vtx)))


class CUnsignedAlert(object):

    def __init__(self):
        self.nVersion = 1
        self.nRelayUntil = 0
        self.nExpiration = 0
        self.nID = 0
        self.nCancel = 0
        self.setCancel = []
        self.nMinVer = 0
        self.nMaxVer = 0
        self.setSubVer = []
        self.nPriority = 0
        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.setCancel = deser_int_vector(f)
        self.nMinVer = struct.unpack('<i', f.read(4))[0]
        self.nMaxVer = struct.unpack('<i', f.read(4))[0]
        self.setSubVer = deser_string_vector(f)
        self.nPriority = struct.unpack('<i', f.read(4))[0]
        self.strComment = deser_string(f)
        self.strStatusBar = deser_string(f)
        self.strReserved = deser_string(f)

    def serialize(self):
        r = b''
        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 += ser_int_vector(self.setCancel)
        r += struct.pack('<i', self.nMinVer)
        r += struct.pack('<i', self.nMaxVer)
        r += ser_string_vector(self.setSubVer)
        r += struct.pack('<i', self.nPriority)
        r += ser_string(self.strComment)
        r += ser_string(self.strStatusBar)
        r += ser_string(self.strReserved)
        return r

    def __repr__(self):
        return (
            'CUnsignedAlert(nVersion %d, nRelayUntil %d, nExpiration %d, nID %d, nCancel %d, nMinVer %d, nMaxVer %d, nPriority %d, strComment %s, strStatusBar %s, strReserved %s)'
             % (self.nVersion, self.nRelayUntil, self.nExpiration, self.nID,
            self.nCancel, self.nMinVer, self.nMaxVer, self.nPriority, self.
            strComment, self.strStatusBar, self.strReserved))


class CAlert(object):

    def __init__(self):
        self.vchMsg = b''
        self.vchSig = b''

    def deserialize(self, f):
        self.vchMsg = deser_string(f)
        self.vchSig = deser_string(f)

    def serialize(self):
        r = b''
        r += ser_string(self.vchMsg)
        r += ser_string(self.vchSig)
        return r

    def __repr__(self):
        return 'CAlert(vchMsg.sz %d, vchSig.sz %d)' % (len(self.vchMsg),
            len(self.vchSig))


class PrefilledTransaction(object):

    def __init__(self, index=0, tx=None):
        self.index = index
        self.tx = tx

    def deserialize(self, f):
        self.index = deser_compact_size(f)
        self.tx = CTransaction()
        self.tx.deserialize(f)

    def serialize(self):
        r = b''
        r += ser_compact_size(self.index)
        r += self.tx.serialize()
        return r

    def __repr__(self):
        return 'PrefilledTransaction(index=%d, tx=%s)' % (self.index, repr(
            self.tx))


class P2PHeaderAndShortIDs(object):

    def __init__(self):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids_length = 0
        self.shortids = []
        self.prefilled_txn_length = 0
        self.prefilled_txn = []

    def deserialize(self, f):
        self.header.deserialize(f)
        self.nonce = struct.unpack('<Q', f.read(8))[0]
        self.shortids_length = deser_compact_size(f)
        for i in range(self.shortids_length):
            self.shortids.append(struct.unpack('<Q', f.read(6) +
                b'\x00\x00')[0])
        self.prefilled_txn = deser_vector(f, PrefilledTransaction)
        self.prefilled_txn_length = len(self.prefilled_txn)

    def serialize(self):
        r = b''
        r += self.header.serialize()
        r += struct.pack('<Q', self.nonce)
        r += ser_compact_size(self.shortids_length)
        for x in self.shortids:
            r += struct.pack('<Q', x)[0:6]
        r += ser_vector(self.prefilled_txn)
        return r

    def __repr__(self):
        return (
            'P2PHeaderAndShortIDs(header=%s, nonce=%d, shortids_length=%d, shortids=%s, prefilled_txn_length=%d, prefilledtxn=%s'
             % (repr(self.header), self.nonce, self.shortids_length, repr(
            self.shortids), self.prefilled_txn_length, repr(self.
            prefilled_txn)))


<mask token>


class HeaderAndShortIDs(object):

    def __init__(self, p2pheaders_and_shortids=None):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids = []
        self.prefilled_txn = []
        if p2pheaders_and_shortids != None:
            self.header = p2pheaders_and_shortids.header
            self.nonce = p2pheaders_and_shortids.nonce
            self.shortids = p2pheaders_and_shortids.shortids
            last_index = -1
            for x in p2pheaders_and_shortids.prefilled_txn:
                self.prefilled_txn.append(PrefilledTransaction(x.index +
                    last_index + 1, x.tx))
                last_index = self.prefilled_txn[-1].index

    def to_p2p(self):
        ret = P2PHeaderAndShortIDs()
        ret.header = self.header
        ret.nonce = self.nonce
        ret.shortids_length = len(self.shortids)
        ret.shortids = self.shortids
        ret.prefilled_txn_length = len(self.prefilled_txn)
        ret.prefilled_txn = []
        last_index = -1
        for x in self.prefilled_txn:
            ret.prefilled_txn.append(PrefilledTransaction(x.index -
                last_index - 1, x.tx))
            last_index = x.index
        return ret

    def get_siphash_keys(self):
        header_nonce = self.header.serialize()
        header_nonce += struct.pack('<Q', self.nonce)
        hash_header_nonce_as_str = sha256(header_nonce)
        key0 = struct.unpack('<Q', hash_header_nonce_as_str[0:8])[0]
        key1 = struct.unpack('<Q', hash_header_nonce_as_str[8:16])[0]
        return [key0, key1]

    def initialize_from_block(self, block, nonce=0, prefill_list=[0]):
        self.header = CBlockHeader(block)
        self.nonce = nonce
        self.prefilled_txn = [PrefilledTransaction(i, block.vtx[i]) for i in
            prefill_list]
        self.shortids = []
        [k0, k1] = self.get_siphash_keys()
        for i in range(len(block.vtx)):
            if i not in prefill_list:
                self.shortids.append(calculate_shortid(k0, k1, block.vtx[i]
                    .sha256))

    def __repr__(self):
        return (
            'HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s'
             % (repr(self.header), self.nonce, repr(self.shortids), repr(
            self.prefilled_txn)))


class BlockTransactionsRequest(object):

    def __init__(self, blockhash=0, indexes=None):
        self.blockhash = blockhash
        self.indexes = indexes if indexes != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        indexes_length = deser_compact_size(f)
        for i in range(indexes_length):
            self.indexes.append(deser_compact_size(f))

    def serialize(self):
        r = b''
        r += ser_uint256(self.blockhash)
        r += ser_compact_size(len(self.indexes))
        for x in self.indexes:
            r += ser_compact_size(x)
        return r

    def from_absolute(self, absolute_indexes):
        self.indexes = []
        last_index = -1
        for x in absolute_indexes:
            self.indexes.append(x - last_index - 1)
            last_index = x

    def to_absolute(self):
        absolute_indexes = []
        last_index = -1
        for x in self.indexes:
            absolute_indexes.append(x + last_index + 1)
            last_index = absolute_indexes[-1]
        return absolute_indexes

    def __repr__(self):
        return 'BlockTransactionsRequest(hash=%064x indexes=%s)' % (self.
            blockhash, repr(self.indexes))


class BlockTransactions(object):

    def __init__(self, blockhash=0, transactions=None):
        self.blockhash = blockhash
        self.transactions = transactions if transactions != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        self.transactions = deser_vector(f, CTransaction)

    def serialize(self, with_witness=False):
        r = b''
        r += ser_uint256(self.blockhash)
        if with_witness:
            r += ser_vector(self.transactions, 'serialize_with_witness')
        else:
            r += ser_vector(self.transactions)
        return r

    def __repr__(self):
        return 'BlockTransactions(hash=%064x transactions=%s)' % (self.
            blockhash, repr(self.transactions))


class msg_version(object):
    command = b'version'

    def __init__(self):
        self.nVersion = MY_VERSION
        self.nServices = 1
        self.nTime = int(time.time())
        self.addrTo = CAddressInVersion()
        self.addrFrom = CAddressInVersion()
        self.nNonce = random.getrandbits(64)
        self.strSubVer = MY_SUBVERSION
        self.nStartingHeight = -1

    def deserialize(self, f):
        self.nVersion = struct.unpack('<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.addrTo = CAddressInVersion()
        self.addrTo.deserialize(f)
        if self.nVersion >= 106:
            self.addrFrom = CAddressInVersion()
            self.addrFrom.deserialize(f)
            self.nNonce = struct.unpack('<Q', f.read(8))[0]
            self.strSubVer = deser_string(f)
            if self.nVersion >= 209:
                self.nStartingHeight = struct.unpack('<i', f.read(4))[0]
            else:
                self.nStartingHeight = None
        else:
            self.addrFrom = None
            self.nNonce = None
            self.strSubVer = None
            self.nStartingHeight = None

    def serialize(self):
        r = b''
        r += struct.pack('<i', self.nVersion)
        r += struct.pack('<Q', self.nServices)
        r += struct.pack('<q', self.nTime)
        r += self.addrTo.serialize()
        r += self.addrFrom.serialize()
        r += struct.pack('<Q', self.nNonce)
        r += ser_string(self.strSubVer)
        r += struct.pack('<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 = b'verack'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_verack()'


class msg_extversion(object):
    command = b'extversion'

    def __init__(self, xver={}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return 'msg_extversion(%s)' % repr(self.xver)


class msg_xupdate(object):
    command = b'xupdate'

    def __init__(self, xver={}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return 'msg_xupdate(%s)' % repr(self.xver)


class msg_addr(object):
    command = b'addr'

    def __init__(self):
        self.addrs = []

    def deserialize(self, f):
        self.addrs = deser_vector(f, CAddress)

    def serialize(self):
        return ser_vector(self.addrs)

    def __repr__(self):
        return 'msg_addr(addrs=%s)' % repr(self.addrs)


class msg_alert(object):
    command = b'alert'

    def __init__(self):
        self.alert = CAlert()

    def deserialize(self, f):
        self.alert = CAlert()
        self.alert.deserialize(f)

    def serialize(self):
        r = b''
        r += self.alert.serialize()
        return r

    def __repr__(self):
        return 'msg_alert(alert=%s)' % (repr(self.alert),)


class msg_inv(object):
    command = b'inv'

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        else:
            self.inv = inv

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return 'msg_inv(inv=%s)' % repr(self.inv)


class msg_getdata(object):
    command = b'getdata'

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        elif type(inv) == list:
            self.inv = inv
        else:
            self.inv = [inv]

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return 'msg_getdata(inv=%s)' % repr(self.inv)


class msg_getblocks(object):
    command = b'getblocks'

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b''
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return 'msg_getblocks(locator=%s hashstop=%064x)' % (repr(self.
            locator), self.hashstop)


class msg_tx(object):
    command = b'tx'

    def __init__(self, tx=CTransaction()):
        self.tx = tx

    def deserialize(self, f):
        self.tx.deserialize(f)

    def serialize(self):
        return self.tx.serialize()

    def __repr__(self):
        return 'msg_tx(tx=%s)' % repr(self.tx)


class msg_block(object):
    command = b'block'

    def __init__(self, block=None):
        if block is None:
            self.block = CBlock()
        else:
            self.block = block

    def deserialize(self, f):
        self.block.deserialize(f)

    def serialize(self):
        return self.block.serialize()

    def __str__(self):
        return 'msg_block(block=%s)' % str(self.block)

    def __repr__(self):
        return 'msg_block(block=%s)' % repr(self.block)


class msg_getaddr(object):
    command = b'getaddr'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_getaddr()'


class msg_ping(object):
    command = b'ping'

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nonce)
        return r

    def __repr__(self):
        return 'msg_ping(nonce=%08x)' % self.nonce


class msg_pong(object):
    command = b'pong'

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nonce)
        return r

    def __repr__(self):
        return 'msg_pong(nonce=%08x)' % self.nonce


class msg_mempool(object):
    command = b'mempool'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_mempool()'


class msg_sendheaders(object):
    command = b'sendheaders'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_sendheaders()'


class msg_getheaders(object):
    """
    getheaders message has
    locator: CBlockLocator object that identifies what block to start with
    hash_stop: hash of last desired block header, 0 to get as many as possible
    """
    command = b'getheaders'

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b''
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return 'msg_getheaders(locator=%s, stop=%064x)' % (repr(self.
            locator), self.hashstop)


class msg_headers(object):
    """
    headers message has
    <count> <vector of block headers>
    """
    command = b'headers'

    def __init__(self, headers=None):
        self.headers = [] if headers is None else headers

    def deserialize(self, f):
        blocks = deser_vector(f, CBlock)
        for x in blocks:
            self.headers.append(CBlockHeader(x))

    def serialize(self):
        blocks = [CBlock(x) for x in self.headers]
        return ser_vector(blocks)

    def __repr__(self):
        return 'msg_headers(headers=%s)' % repr(self.headers)


class msg_reject(object):
    command = b'reject'
    REJECT_MALFORMED = 1

    def __init__(self):
        self.message = b''
        self.code = 0
        self.reason = b''
        self.data = 0

    def deserialize(self, f):
        self.message = deser_string(f)
        self.code = struct.unpack('<B', f.read(1))[0]
        self.reason = deser_string(f)
        if self.code != self.REJECT_MALFORMED and (self.message == b'block' or
            self.message == b'tx'):
            self.data = deser_uint256(f)

    def serialize(self):
        r = ser_string(self.message)
        r += struct.pack('<B', self.code)
        r += ser_string(self.reason)
        if self.code != self.REJECT_MALFORMED and (self.message == b'block' or
            self.message == b'tx'):
            r += ser_uint256(self.data)
        return r

    def __repr__(self):
        return 'msg_reject: %s %d %s [%064x]' % (self.message, self.code,
            self.reason, self.data)


class msg_sendcmpct(object):
    command = b'sendcmpct'

    def __init__(self):
        self.announce = False
        self.version = 1

    def deserialize(self, f):
        self.announce = struct.unpack('<?', f.read(1))[0]
        self.version = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<?', self.announce)
        r += struct.pack('<Q', self.version)
        return r

    def __repr__(self):
        return 'msg_sendcmpct(announce=%s, version=%lu)' % (self.announce,
            self.version)


class msg_cmpctblock(object):
    command = b'cmpctblock'

    def __init__(self, header_and_shortids=None):
        self.header_and_shortids = header_and_shortids

    def deserialize(self, f):
        self.header_and_shortids = P2PHeaderAndShortIDs()
        self.header_and_shortids.deserialize(f)

    def serialize(self):
        r = b''
        r += self.header_and_shortids.serialize()
        return r

    def __repr__(self):
        return 'msg_cmpctblock(HeaderAndShortIDs=%s)' % repr(self.
            header_and_shortids)


class msg_getblocktxn(object):
    command = b'getblocktxn'

    def __init__(self):
        self.block_txn_request = None

    def deserialize(self, f):
        self.block_txn_request = BlockTransactionsRequest()
        self.block_txn_request.deserialize(f)

    def serialize(self):
        r = b''
        r += self.block_txn_request.serialize()
        return r

    def __repr__(self):
        return 'msg_getblocktxn(block_txn_request=%s)' % repr(self.
            block_txn_request)


class msg_blocktxn(object):
    command = b'blocktxn'

    def __init__(self):
        self.block_transactions = BlockTransactions()

    def deserialize(self, f):
        self.block_transactions.deserialize(f)

    def serialize(self):
        r = b''
        r += self.block_transactions.serialize()
        return r

    def __repr__(self):
        return 'msg_blocktxn(block_transactions=%s)' % repr(self.
            block_transactions)


<mask token>

<mask token>


class InvalidBase58Error(Exception):
    """Raised on generic invalid base58 data, such as bad characters.
    Checksum failures raise Base58ChecksumError specifically.
    """
    pass


<mask token>


class CompactSize(int):

    def serialize(self):
        assert self >= 0
        if self < 253:
            return struct.pack('<B', self)
        elif self < 2 ** 16:
            return struct.pack('<B', 253) + struct.pack('<H', self)
        elif self < 2 ** 32:
            return struct.pack('<B', 254) + struct.pack('<I', self)
        elif self < 2 ** 64:
            return struct.pack('<B', 255) + struct.pack('<Q', self)

    def deserialize(self, f):
        self = struct.unpack('<B', f.read(1))[0]
        if self == 253:
            self = struct.unpack('<H', f.read(2))[0]
        elif self == 254:
            self = struct.unpack('<I', f.read(4))[0]
        elif self == 255:
            self = struct.unpack('<Q', f.read(8))[0]
        return self


<mask token>


def uint256_from_bigendian(s):
    """Decode a uint256 from a big-endian byte array or hex string (lexical order is big-endian)
    """
    if type(s) is str:
        s = unhexlify(s)
    r = 0
    t = struct.unpack('>QQQQ', s[:32])
    for i in t:
        r = r << 64 | i
    return r


<mask token>


class CAddressInVersion(object):

    def __init__(self, ip='0.0.0.0', port=0):
        self.nServices = 1
        self.pchReserved = b'\x00' * 10 + b'\xff' * 2
        self.ip = ip
        self.port = port

    def deserialize(self, f):
        self.nServices = struct.unpack('<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]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nServices)
        r += self.pchReserved
        r += socket.inet_aton(self.ip)
        r += struct.pack('>H', self.port)
        return r

    def __repr__(self):
        return 'CAddressInVersion(nServices=%i ip=%s port=%i)' % (self.
            nServices, self.ip, self.port)


class CAddress(object):

    def __init__(self, ip='0.0.0.0', port=0):
        self.nServices = 1
        self.nTime = int(time.time())
        self.pchReserved = b'\x00' * 10 + b'\xff' * 2
        self.ip = ip
        self.port = port

    def deserialize(self, f):
        self.nTime = struct.unpack('<L', f.read(4))[0]
        self.nServices = struct.unpack('<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]

    def serialize(self):
        r = b''
        r += struct.pack('<L', self.nTime)
        r += struct.pack('<Q', self.nServices)
        r += self.pchReserved
        r += socket.inet_aton(self.ip)
        r += struct.pack('>H', self.port)
        return r

    def __repr__(self):
        return 'CAddress(nServices=%i ip=%s port=%i time=%d)' % (self.
            nServices, self.ip, self.port, self.nTime)


class CInv(object):
    MSG_TX = 1
    MSG_BLOCK = 2
    MSG_FILTERED_BLOCK = 3
    MSG_CMPCT_BLOCK = 4
    MSG_XTHINBLOCK = 5
    MSG_THINBLOCK = MSG_CMPCT_BLOCK
    typemap = {(0): 'Error', (1): 'TX', (2): 'Block', (3): 'FilteredBlock',
        (4): 'CompactBlock', (5): 'XThinBlock'}

    def __init__(self, t=0, h=0):
        self.type = t
        self.hash = h

    def deserialize(self, f):
        self.type = struct.unpack('<i', f.read(4))[0]
        self.hash = deser_uint256(f)

    def serialize(self):
        r = b''
        r += struct.pack('<i', self.type)
        r += ser_uint256(self.hash)
        return r

    def __repr__(self):
        return 'CInv(type=%s hash=%064x)' % (self.typemap[self.type], self.hash
            )


class CBlockLocator(object):

    def __init__(self):
        self.nVersion = MY_VERSION
        self.vHave = []

    def deserialize(self, f):
        self.nVersion = struct.unpack('<i', f.read(4))[0]
        self.vHave = deser_uint256_vector(f)

    def serialize(self):
        r = b''
        r += struct.pack('<i', self.nVersion)
        r += ser_uint256_vector(self.vHave)
        return r

    def __repr__(self):
        return 'CBlockLocator(nVersion=%i vHave=%s)' % (self.nVersion, repr
            (self.vHave))


class COutPoint(object):

    def __init__(self, hash=0, n=0):
        if type(hash) is str:
            hash = uint256_from_bigendian(hash)
        if type(hash) is bytes:
            hash = uint256_from_str(hash)
        self.hash = hash
        self.n = n

    def deserialize(self, f):
        self.hash = deser_uint256(f)
        self.n = struct.unpack('<I', f.read(4))[0]

    def serialize(self):
        r = b''
        r += ser_uint256(self.hash)
        r += struct.pack('<I', self.n)
        return r

    def __repr__(self):
        return 'COutPoint(hash=%064x n=%i)' % (self.hash, self.n)


class CTxIn(object):

    def __init__(self, outpoint=None, scriptSig=b'', nSequence=0):
        if outpoint is None:
            self.prevout = COutPoint()
        else:
            self.prevout = outpoint
        self.scriptSig = scriptSig
        self.nSequence = nSequence

    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]

    def serialize(self):
        r = b''
        r += self.prevout.serialize()
        r += ser_string(self.scriptSig)
        r += struct.pack('<I', self.nSequence)
        return r

    def __repr__(self):
        return 'CTxIn(prevout=%s scriptSig=%s nSequence=%i)' % (repr(self.
            prevout), hexlify(self.scriptSig), self.nSequence)


class CTxOut(object):

    def __init__(self, nValue=0, scriptPubKey=b''):
        self.nValue = nValue
        self.scriptPubKey = scriptPubKey

    def deserialize(self, f):
        self.nValue = struct.unpack('<q', f.read(8))[0]
        self.scriptPubKey = deser_string(f)

    def serialize(self):
        r = b''
        r += struct.pack('<q', int(self.nValue))
        r += ser_string(self.scriptPubKey)
        return r

    def __repr__(self):
        return 'CTxOut(nValue=%i.%08i scriptPubKey=%s)' % (self.nValue //
            COIN, self.nValue % COIN, hexlify(self.scriptPubKey))


class CTransaction(object):

    def __init__(self, tx=None):
        if tx is None:
            self.nVersion = 1
            self.vin = []
            self.vout = []
            self.nLockTime = 0
            self.sha256 = None
            self.hash = None
        else:
            self.nVersion = tx.nVersion
            self.vin = copy.deepcopy(tx.vin)
            self.vout = copy.deepcopy(tx.vout)
            self.nLockTime = tx.nLockTime
            self.sha256 = None
            self.hash = None

    def deserialize(self, f):
        if isinstance(f, str):
            f = BytesIO(unhexlify(f))
        elif isinstance(f, bytes):
            f = BytesIO(f)
        self.nVersion = struct.unpack('<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.sha256 = None
        self.hash = None
        return self

    def serialize(self):
        r = b''
        r += struct.pack('<i', self.nVersion)
        r += ser_vector(self.vin)
        r += ser_vector(self.vout)
        r += struct.pack('<I', self.nLockTime)
        return r

    def toHex(self):
        """Return the hex string serialization of this object"""
        return hexlify(self.serialize()).decode('utf-8')

    def rehash(self):
        self.sha256 = None
        self.calc_sha256()
        return self.hash

    def calc_sha256(self):
        if self.sha256 is None:
            self.sha256 = uint256_from_str(hash256(self.serialize()))
        self.hash = encode(hash256(self.serialize())[::-1], 'hex_codec'
            ).decode('ascii')
        return self.hash

    def getHash(self):
        if self.sha256 is None:
            self.rehash()
        return self.sha256

    def is_valid(self):
        self.calc_sha256()
        for tout in self.vout:
            if tout.nValue < 0 or tout.nValue > 21000000 * COIN:
                return False
        return True

    def summary(self):
        self.calc_sha256()
        s = ['Transaction: %064x\n' % self.sha256]
        s.append('%d inputs\n' % len(self.vin))
        for vin in self.vin:
            s.append('  %064x:%d\n' % (vin.prevout.hash, vin.prevout.n))
        s.append('%d outputs\n' % len(self.vout))
        for vout in self.vout:
            s.append('  %12d %s\n' % (vout.nValue, hexlify(vout.scriptPubKey)))
        return ''.join(s)

    def __repr__(self):
        return 'CTransaction(nVersion=%i vin=%s vout=%s nLockTime=%i)' % (self
            .nVersion, repr(self.vin), repr(self.vout), self.nLockTime)

    def SignatureHash(self, in_number, scriptCode, nValue, hashcode=
        SIGHASH_ALL | SIGHASH_FORKID, single=False, debug=False):
        """Calculate hash digest for given input, using SIGHASH_FORKID
        (Bitcoin Cash signing). Returns it in binary, little-endian.

        txin is the corresponding input CTransaction. Supplying it is
        necessary to include the scriptPubKey in the hashed output.

        If single is True, just a single invocation of SHA256 is done,
        instead of the usual, expected double hashing. This is to aid
        applications such as CHECKDATASIG(VERIFY).
        """
        hashdata = struct.pack('<I', self.nVersion)
        h_prevouts = self.hashPrevouts(hashcode)
        if debug:
            print('Hash prevouts:', hexlify(h_prevouts[::-1]))
        hashdata += h_prevouts
        h_sequence = self.hashSequence(hashcode)
        if debug:
            print('Hash sequence:', hexlify(h_sequence[::-1]))
        hashdata += h_sequence
        hashdata += self.vin[in_number].prevout.serialize()
        assert 75 >= len(scriptCode) > 0
        hashdata += struct.pack('<B', len(scriptCode))
        hashdata += scriptCode
        hashdata += struct.pack('<Q', nValue)
        hashdata += struct.pack('<I', self.vin[in_number].nSequence)
        h_outputs = self.hashOutputs(hashcode, in_number)
        if debug:
            print('Hash outputs:', hexlify(h_outputs[::-1]))
        hashdata += h_outputs
        hashdata += struct.pack('<I', self.nLockTime)
        hashdata += struct.pack('<I', hashcode)
        if debug:
            print('Hash all data:', hexlify(hashdata))
        if single:
            return sha256(hashdata)
        else:
            return hash256(hashdata)

    def hashPrevouts(self, hashcode):
        if hashcode & SIGHASH_ANYONECANPAY:
            return 32 * b'\x00'
        else:
            op_ser = b''
            for inp in self.vin:
                op_ser += inp.prevout.serialize()
            return hash256(op_ser)

    def hashSequence(self, hashcode):
        if (hashcode & SIGHASH_ANYONECANPAY or hashcode & 31 ==
            SIGHASH_SINGLE or hashcode & 31 == SIGHASH_NONE):
            return 32 * b'\x00'
        else:
            seq_ser = b''
            for inp in self.vin:
                seq_ser += struct.pack('<I', inp.nSequence)
            return hash256(seq_ser)

    def hashOutputs(self, hashcode, in_number):
        if hashcode & 31 == SIGHASH_SINGLE and in_number < len(self.vout):
            return hash256(self.vout[in_number].serialize())
        elif not hashcode & 31 == SIGHASH_SINGLE and not hashcode & 31 == SIGHASH_NONE:
            out_ser = b''
            for out in self.vout:
                out_ser += out.serialize()
            return hash256(out_ser)
        else:
            return 32 * b'\x00'

    def SignatureHashLegacy(self, script, inIdx, hashtype):
        """Consensus-correct SignatureHash (legacy variant)

        Returns (hash, err) to precisely match the consensus-critical behavior of
        the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity)
        """
        from .script import FindAndDelete, CScript, OP_CODESEPARATOR
        HASH_ONE = (
            b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
            )
        if inIdx >= len(self.vin):
            return HASH_ONE, 'inIdx %d out of range (%d)' % (inIdx, len(
                self.vin))
        txtmp = CTransaction(self)
        for txin in txtmp.vin:
            txin.scriptSig = b''
        txtmp.vin[inIdx].scriptSig = FindAndDelete(script, CScript([
            OP_CODESEPARATOR]))
        if hashtype & 31 == SIGHASH_NONE:
            txtmp.vout = []
            for i in range(len(txtmp.vin)):
                if i != inIdx:
                    txtmp.vin[i].nSequence = 0
        elif hashtype & 31 == SIGHASH_SINGLE:
            outIdx = inIdx
            if outIdx >= len(txtmp.vout):
                return HASH_ONE, 'outIdx %d out of range (%d)' % (outIdx,
                    len(txtmp.vout))
            tmp = txtmp.vout[outIdx]
            txtmp.vout = []
            for i in range(outIdx):
                txtmp.vout.append(CTxOut())
            txtmp.vout.append(tmp)
            for i in range(len(txtmp.vin)):
                if i != inIdx:
                    txtmp.vin[i].nSequence = 0
        if hashtype & SIGHASH_ANYONECANPAY:
            tmp = txtmp.vin[inIdx]
            txtmp.vin = []
            txtmp.vin.append(tmp)
        s = txtmp.serialize()
        s += struct.pack(b'<I', hashtype)
        hash = hash256(s)
        return hash, None


class CBlockHeader(object):

    def __init__(self, header=None):
        if header is None:
            self.set_null()
        else:
            self.nVersion = header.nVersion
            self.hashPrevBlock = header.hashPrevBlock
            self.hashMerkleRoot = header.hashMerkleRoot
            self.nTime = header.nTime
            self.nBits = header.nBits
            self.nNonce = header.nNonce
            self.sha256 = header.sha256
            self.hash = header.hash
            self.calc_sha256()

    def set_null(self):
        self.nVersion = 1
        self.hashPrevBlock = 0
        self.hashMerkleRoot = 0
        self.nTime = 0
        self.nBits = 0
        self.nNonce = 0
        self.sha256 = None
        self.hash = None

    def deserialize(self, f):
        self.nVersion = struct.unpack('<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.sha256 = None
        self.hash = None

    def serialize(self):
        r = b''
        r += struct.pack('<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)
        return r

    def calc_sha256(self):
        if self.sha256 is None:
            r = b''
            r += struct.pack('<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)
            self.sha256 = uint256_from_str(hash256(r))
            self.hash = encode(hash256(r)[::-1], 'hex_codec').decode('ascii')
        return self.hash

    def gethashprevblock(self, encoding='int'):
        assert encoding == 'hex' or encoding == 'int'
        if encoding == 'int':
            return self.hashPrevBlock
        return hex(self.hashPrevBlock)

    def gethash(self, encoding='int'):
        assert encoding == 'hex' or encoding == 'int'
        self.calc_sha256()
        if encoding == 'int':
            return self.sha256
        return hex(self.sha256)

    def rehash(self):
        self.sha256 = None
        self.calc_sha256()
        return self.sha256

    def summary(self):
        s = []
        s.append('Block:  %064x  Time:%s  Version:0x%x Bits:0x%08x\n' % (
            self.gethash(), time.ctime(self.nTime), self.nVersion, self.nBits))
        s.append('Parent: %064x  Merkle: %064x' % (self.hashPrevBlock, self
            .hashMerkleRoot))
        return ''.join(s)

    def __str__(self):
        return (
            'CBlockHeader(hash=%064x nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)'
             % (self.gethash(), self.nVersion, self.hashPrevBlock, self.
            hashMerkleRoot, time.ctime(self.nTime), self.nBits, self.nNonce))

    def __repr__(self):
        return (
            'CBlockHeader(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)'
             % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
            time.ctime(self.nTime), self.nBits, self.nNonce))


class CBlock(CBlockHeader):

    def __init__(self, header=None):
        super(CBlock, self).__init__(header)
        self.vtx = []

    def deserialize(self, f):
        super(CBlock, self).deserialize(f)
        self.vtx = deser_vector(f, CTransaction)

    def serialize(self):
        r = b''
        r += super(CBlock, self).serialize()
        r += ser_vector(self.vtx)
        return r

    def calc_merkle_root(self):
        hashes = []
        for tx in self.vtx:
            tx.calc_sha256()
            hashes.append(ser_uint256(tx.sha256))
        while len(hashes) > 1:
            newhashes = []
            for i in range(0, len(hashes), 2):
                i2 = min(i + 1, len(hashes) - 1)
                newhashes.append(hash256(hashes[i] + hashes[i2]))
            hashes = newhashes
        if hashes:
            return uint256_from_str(hashes[0])
        return 0

    def is_valid(self):
        self.calc_sha256()
        target = uint256_from_compact(self.nBits)
        if self.sha256 > target:
            return False
        for tx in self.vtx:
            if not tx.is_valid():
                return False
        if self.calc_merkle_root() != self.hashMerkleRoot:
            return False
        return True

    def solve(self):
        self.rehash()
        target = uint256_from_compact(self.nBits)
        while self.sha256 > target:
            self.nNonce += 1
            self.rehash()

    def __str__(self):
        return (
            'CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx_len=%d)'
             % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
            time.ctime(self.nTime), self.nBits, self.nNonce, len(self.vtx)))

    def __repr__(self):
        return (
            'CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%s)'
             % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
            time.ctime(self.nTime), self.nBits, self.nNonce, repr(self.vtx)))


class CUnsignedAlert(object):

    def __init__(self):
        self.nVersion = 1
        self.nRelayUntil = 0
        self.nExpiration = 0
        self.nID = 0
        self.nCancel = 0
        self.setCancel = []
        self.nMinVer = 0
        self.nMaxVer = 0
        self.setSubVer = []
        self.nPriority = 0
        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.setCancel = deser_int_vector(f)
        self.nMinVer = struct.unpack('<i', f.read(4))[0]
        self.nMaxVer = struct.unpack('<i', f.read(4))[0]
        self.setSubVer = deser_string_vector(f)
        self.nPriority = struct.unpack('<i', f.read(4))[0]
        self.strComment = deser_string(f)
        self.strStatusBar = deser_string(f)
        self.strReserved = deser_string(f)

    def serialize(self):
        r = b''
        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 += ser_int_vector(self.setCancel)
        r += struct.pack('<i', self.nMinVer)
        r += struct.pack('<i', self.nMaxVer)
        r += ser_string_vector(self.setSubVer)
        r += struct.pack('<i', self.nPriority)
        r += ser_string(self.strComment)
        r += ser_string(self.strStatusBar)
        r += ser_string(self.strReserved)
        return r

    def __repr__(self):
        return (
            'CUnsignedAlert(nVersion %d, nRelayUntil %d, nExpiration %d, nID %d, nCancel %d, nMinVer %d, nMaxVer %d, nPriority %d, strComment %s, strStatusBar %s, strReserved %s)'
             % (self.nVersion, self.nRelayUntil, self.nExpiration, self.nID,
            self.nCancel, self.nMinVer, self.nMaxVer, self.nPriority, self.
            strComment, self.strStatusBar, self.strReserved))


class CAlert(object):

    def __init__(self):
        self.vchMsg = b''
        self.vchSig = b''

    def deserialize(self, f):
        self.vchMsg = deser_string(f)
        self.vchSig = deser_string(f)

    def serialize(self):
        r = b''
        r += ser_string(self.vchMsg)
        r += ser_string(self.vchSig)
        return r

    def __repr__(self):
        return 'CAlert(vchMsg.sz %d, vchSig.sz %d)' % (len(self.vchMsg),
            len(self.vchSig))


class PrefilledTransaction(object):

    def __init__(self, index=0, tx=None):
        self.index = index
        self.tx = tx

    def deserialize(self, f):
        self.index = deser_compact_size(f)
        self.tx = CTransaction()
        self.tx.deserialize(f)

    def serialize(self):
        r = b''
        r += ser_compact_size(self.index)
        r += self.tx.serialize()
        return r

    def __repr__(self):
        return 'PrefilledTransaction(index=%d, tx=%s)' % (self.index, repr(
            self.tx))


class P2PHeaderAndShortIDs(object):

    def __init__(self):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids_length = 0
        self.shortids = []
        self.prefilled_txn_length = 0
        self.prefilled_txn = []

    def deserialize(self, f):
        self.header.deserialize(f)
        self.nonce = struct.unpack('<Q', f.read(8))[0]
        self.shortids_length = deser_compact_size(f)
        for i in range(self.shortids_length):
            self.shortids.append(struct.unpack('<Q', f.read(6) +
                b'\x00\x00')[0])
        self.prefilled_txn = deser_vector(f, PrefilledTransaction)
        self.prefilled_txn_length = len(self.prefilled_txn)

    def serialize(self):
        r = b''
        r += self.header.serialize()
        r += struct.pack('<Q', self.nonce)
        r += ser_compact_size(self.shortids_length)
        for x in self.shortids:
            r += struct.pack('<Q', x)[0:6]
        r += ser_vector(self.prefilled_txn)
        return r

    def __repr__(self):
        return (
            'P2PHeaderAndShortIDs(header=%s, nonce=%d, shortids_length=%d, shortids=%s, prefilled_txn_length=%d, prefilledtxn=%s'
             % (repr(self.header), self.nonce, self.shortids_length, repr(
            self.shortids), self.prefilled_txn_length, repr(self.
            prefilled_txn)))


<mask token>


class HeaderAndShortIDs(object):

    def __init__(self, p2pheaders_and_shortids=None):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids = []
        self.prefilled_txn = []
        if p2pheaders_and_shortids != None:
            self.header = p2pheaders_and_shortids.header
            self.nonce = p2pheaders_and_shortids.nonce
            self.shortids = p2pheaders_and_shortids.shortids
            last_index = -1
            for x in p2pheaders_and_shortids.prefilled_txn:
                self.prefilled_txn.append(PrefilledTransaction(x.index +
                    last_index + 1, x.tx))
                last_index = self.prefilled_txn[-1].index

    def to_p2p(self):
        ret = P2PHeaderAndShortIDs()
        ret.header = self.header
        ret.nonce = self.nonce
        ret.shortids_length = len(self.shortids)
        ret.shortids = self.shortids
        ret.prefilled_txn_length = len(self.prefilled_txn)
        ret.prefilled_txn = []
        last_index = -1
        for x in self.prefilled_txn:
            ret.prefilled_txn.append(PrefilledTransaction(x.index -
                last_index - 1, x.tx))
            last_index = x.index
        return ret

    def get_siphash_keys(self):
        header_nonce = self.header.serialize()
        header_nonce += struct.pack('<Q', self.nonce)
        hash_header_nonce_as_str = sha256(header_nonce)
        key0 = struct.unpack('<Q', hash_header_nonce_as_str[0:8])[0]
        key1 = struct.unpack('<Q', hash_header_nonce_as_str[8:16])[0]
        return [key0, key1]

    def initialize_from_block(self, block, nonce=0, prefill_list=[0]):
        self.header = CBlockHeader(block)
        self.nonce = nonce
        self.prefilled_txn = [PrefilledTransaction(i, block.vtx[i]) for i in
            prefill_list]
        self.shortids = []
        [k0, k1] = self.get_siphash_keys()
        for i in range(len(block.vtx)):
            if i not in prefill_list:
                self.shortids.append(calculate_shortid(k0, k1, block.vtx[i]
                    .sha256))

    def __repr__(self):
        return (
            'HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s'
             % (repr(self.header), self.nonce, repr(self.shortids), repr(
            self.prefilled_txn)))


class BlockTransactionsRequest(object):

    def __init__(self, blockhash=0, indexes=None):
        self.blockhash = blockhash
        self.indexes = indexes if indexes != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        indexes_length = deser_compact_size(f)
        for i in range(indexes_length):
            self.indexes.append(deser_compact_size(f))

    def serialize(self):
        r = b''
        r += ser_uint256(self.blockhash)
        r += ser_compact_size(len(self.indexes))
        for x in self.indexes:
            r += ser_compact_size(x)
        return r

    def from_absolute(self, absolute_indexes):
        self.indexes = []
        last_index = -1
        for x in absolute_indexes:
            self.indexes.append(x - last_index - 1)
            last_index = x

    def to_absolute(self):
        absolute_indexes = []
        last_index = -1
        for x in self.indexes:
            absolute_indexes.append(x + last_index + 1)
            last_index = absolute_indexes[-1]
        return absolute_indexes

    def __repr__(self):
        return 'BlockTransactionsRequest(hash=%064x indexes=%s)' % (self.
            blockhash, repr(self.indexes))


class BlockTransactions(object):

    def __init__(self, blockhash=0, transactions=None):
        self.blockhash = blockhash
        self.transactions = transactions if transactions != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        self.transactions = deser_vector(f, CTransaction)

    def serialize(self, with_witness=False):
        r = b''
        r += ser_uint256(self.blockhash)
        if with_witness:
            r += ser_vector(self.transactions, 'serialize_with_witness')
        else:
            r += ser_vector(self.transactions)
        return r

    def __repr__(self):
        return 'BlockTransactions(hash=%064x transactions=%s)' % (self.
            blockhash, repr(self.transactions))


class msg_version(object):
    command = b'version'

    def __init__(self):
        self.nVersion = MY_VERSION
        self.nServices = 1
        self.nTime = int(time.time())
        self.addrTo = CAddressInVersion()
        self.addrFrom = CAddressInVersion()
        self.nNonce = random.getrandbits(64)
        self.strSubVer = MY_SUBVERSION
        self.nStartingHeight = -1

    def deserialize(self, f):
        self.nVersion = struct.unpack('<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.addrTo = CAddressInVersion()
        self.addrTo.deserialize(f)
        if self.nVersion >= 106:
            self.addrFrom = CAddressInVersion()
            self.addrFrom.deserialize(f)
            self.nNonce = struct.unpack('<Q', f.read(8))[0]
            self.strSubVer = deser_string(f)
            if self.nVersion >= 209:
                self.nStartingHeight = struct.unpack('<i', f.read(4))[0]
            else:
                self.nStartingHeight = None
        else:
            self.addrFrom = None
            self.nNonce = None
            self.strSubVer = None
            self.nStartingHeight = None

    def serialize(self):
        r = b''
        r += struct.pack('<i', self.nVersion)
        r += struct.pack('<Q', self.nServices)
        r += struct.pack('<q', self.nTime)
        r += self.addrTo.serialize()
        r += self.addrFrom.serialize()
        r += struct.pack('<Q', self.nNonce)
        r += ser_string(self.strSubVer)
        r += struct.pack('<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 = b'verack'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_verack()'


class msg_extversion(object):
    command = b'extversion'

    def __init__(self, xver={}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return 'msg_extversion(%s)' % repr(self.xver)


class msg_xupdate(object):
    command = b'xupdate'

    def __init__(self, xver={}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return 'msg_xupdate(%s)' % repr(self.xver)


class msg_addr(object):
    command = b'addr'

    def __init__(self):
        self.addrs = []

    def deserialize(self, f):
        self.addrs = deser_vector(f, CAddress)

    def serialize(self):
        return ser_vector(self.addrs)

    def __repr__(self):
        return 'msg_addr(addrs=%s)' % repr(self.addrs)


class msg_alert(object):
    command = b'alert'

    def __init__(self):
        self.alert = CAlert()

    def deserialize(self, f):
        self.alert = CAlert()
        self.alert.deserialize(f)

    def serialize(self):
        r = b''
        r += self.alert.serialize()
        return r

    def __repr__(self):
        return 'msg_alert(alert=%s)' % (repr(self.alert),)


class msg_inv(object):
    command = b'inv'

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        else:
            self.inv = inv

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return 'msg_inv(inv=%s)' % repr(self.inv)


class msg_getdata(object):
    command = b'getdata'

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        elif type(inv) == list:
            self.inv = inv
        else:
            self.inv = [inv]

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return 'msg_getdata(inv=%s)' % repr(self.inv)


class msg_getblocks(object):
    command = b'getblocks'

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b''
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return 'msg_getblocks(locator=%s hashstop=%064x)' % (repr(self.
            locator), self.hashstop)


class msg_tx(object):
    command = b'tx'

    def __init__(self, tx=CTransaction()):
        self.tx = tx

    def deserialize(self, f):
        self.tx.deserialize(f)

    def serialize(self):
        return self.tx.serialize()

    def __repr__(self):
        return 'msg_tx(tx=%s)' % repr(self.tx)


class msg_block(object):
    command = b'block'

    def __init__(self, block=None):
        if block is None:
            self.block = CBlock()
        else:
            self.block = block

    def deserialize(self, f):
        self.block.deserialize(f)

    def serialize(self):
        return self.block.serialize()

    def __str__(self):
        return 'msg_block(block=%s)' % str(self.block)

    def __repr__(self):
        return 'msg_block(block=%s)' % repr(self.block)


class msg_getaddr(object):
    command = b'getaddr'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_getaddr()'


class msg_ping(object):
    command = b'ping'

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nonce)
        return r

    def __repr__(self):
        return 'msg_ping(nonce=%08x)' % self.nonce


class msg_pong(object):
    command = b'pong'

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<Q', self.nonce)
        return r

    def __repr__(self):
        return 'msg_pong(nonce=%08x)' % self.nonce


class msg_mempool(object):
    command = b'mempool'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_mempool()'


class msg_sendheaders(object):
    command = b'sendheaders'

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b''

    def __repr__(self):
        return 'msg_sendheaders()'


class msg_getheaders(object):
    """
    getheaders message has
    locator: CBlockLocator object that identifies what block to start with
    hash_stop: hash of last desired block header, 0 to get as many as possible
    """
    command = b'getheaders'

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b''
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return 'msg_getheaders(locator=%s, stop=%064x)' % (repr(self.
            locator), self.hashstop)


class msg_headers(object):
    """
    headers message has
    <count> <vector of block headers>
    """
    command = b'headers'

    def __init__(self, headers=None):
        self.headers = [] if headers is None else headers

    def deserialize(self, f):
        blocks = deser_vector(f, CBlock)
        for x in blocks:
            self.headers.append(CBlockHeader(x))

    def serialize(self):
        blocks = [CBlock(x) for x in self.headers]
        return ser_vector(blocks)

    def __repr__(self):
        return 'msg_headers(headers=%s)' % repr(self.headers)


class msg_reject(object):
    command = b'reject'
    REJECT_MALFORMED = 1

    def __init__(self):
        self.message = b''
        self.code = 0
        self.reason = b''
        self.data = 0

    def deserialize(self, f):
        self.message = deser_string(f)
        self.code = struct.unpack('<B', f.read(1))[0]
        self.reason = deser_string(f)
        if self.code != self.REJECT_MALFORMED and (self.message == b'block' or
            self.message == b'tx'):
            self.data = deser_uint256(f)

    def serialize(self):
        r = ser_string(self.message)
        r += struct.pack('<B', self.code)
        r += ser_string(self.reason)
        if self.code != self.REJECT_MALFORMED and (self.message == b'block' or
            self.message == b'tx'):
            r += ser_uint256(self.data)
        return r

    def __repr__(self):
        return 'msg_reject: %s %d %s [%064x]' % (self.message, self.code,
            self.reason, self.data)


class msg_sendcmpct(object):
    command = b'sendcmpct'

    def __init__(self):
        self.announce = False
        self.version = 1

    def deserialize(self, f):
        self.announce = struct.unpack('<?', f.read(1))[0]
        self.version = struct.unpack('<Q', f.read(8))[0]

    def serialize(self):
        r = b''
        r += struct.pack('<?', self.announce)
        r += struct.pack('<Q', self.version)
        return r

    def __repr__(self):
        return 'msg_sendcmpct(announce=%s, version=%lu)' % (self.announce,
            self.version)


class msg_cmpctblock(object):
    command = b'cmpctblock'

    def __init__(self, header_and_shortids=None):
        self.header_and_shortids = header_and_shortids

    def deserialize(self, f):
        self.header_and_shortids = P2PHeaderAndShortIDs()
        self.header_and_shortids.deserialize(f)

    def serialize(self):
        r = b''
        r += self.header_and_shortids.serialize()
        return r

    def __repr__(self):
        return 'msg_cmpctblock(HeaderAndShortIDs=%s)' % repr(self.
            header_and_shortids)


class msg_getblocktxn(object):
    command = b'getblocktxn'

    def __init__(self):
        self.block_txn_request = None

    def deserialize(self, f):
        self.block_txn_request = BlockTransactionsRequest()
        self.block_txn_request.deserialize(f)

    def serialize(self):
        r = b''
        r += self.block_txn_request.serialize()
        return r

    def __repr__(self):
        return 'msg_getblocktxn(block_txn_request=%s)' % repr(self.
            block_txn_request)


class msg_blocktxn(object):
    command = b'blocktxn'

    def __init__(self):
        self.block_transactions = BlockTransactions()

    def deserialize(self, f):
        self.block_transactions.deserialize(f)

    def serialize(self):
        r = b''
        r += self.block_transactions.serialize()
        return r

    def __repr__(self):
        return 'msg_blocktxn(block_transactions=%s)' % repr(self.
            block_transactions)


<mask token>

import sys
import socket
import struct
import random
import hashlib
from binascii import hexlify, unhexlify
import time
from codecs import encode
from threading import RLock
from io import BytesIO
import copy
from test_framework.siphash import siphash256
import test_framework.util as util

MY_VERSION = 70014 # past bip-252 for compactblocks

from .constants import SIGHASH_ALL, \
    SIGHASH_FORKID, SIGHASH_ANYONECANPAY, \
    SIGHASH_SINGLE, SIGHASH_NONE

MY_SUBVERSION = b"/python-mininode-tester:0.0.3/"

COIN = 100000000  # 1 btc in satoshis

# One lock for synchronizing all data access between the networking thread (see
# NetworkThread below) and the thread running the test logic.  For simplicity,
# NodeConn acquires this lock whenever delivering a message to a NodeConnCB,
# and whenever adding anything to the send buffer (in send_message()).  This
# lock should be acquired in the thread running the test logic to synchronize
# access to any data shared with the NodeConnCB or NodeConn.
mininode_lock = RLock()

# Helper function

# These functions were moved to util, but keep them in this namespace for backwards compatibility
sha256 = util.sha256
hash256 = util.hash256
hash160 = util.hash160

def wait_until(predicate, attempts=float('inf'), timeout=float('inf')):
    attempt = 0
    elapsed = 0

    while attempt < attempts and elapsed < timeout:
        with mininode_lock:
            if predicate():
                return True
        attempt += 1
        elapsed += 0.05
        time.sleep(0.05)

    return False

def bitcoinAddress2bin(btcAddress):
    """convert a bitcoin address to binary data capable of being put in a CScript"""
    # chop the version and checksum out of the bytes of the address
    return decodeBase58(btcAddress)[1:-4]

B58_DIGITS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

class InvalidBase58Error(Exception):
    """Raised on generic invalid base58 data, such as bad characters.
    Checksum failures raise Base58ChecksumError specifically.
    """
    pass

def decodeBase58(s):
    """Decode a base58-encoding string, returning bytes"""
    if not s:
        return b''

    # Convert the string to an integer
    n = 0
    for c in s:
        n *= 58
        if c not in B58_DIGITS:
            raise InvalidBase58Error('Character %r is not a valid base58 character' % c)
        digit = B58_DIGITS.index(c)
        n += digit

    # Convert the integer to bytes
    h = '%x' % n
    if len(h) % 2:
        h = '0' + h
    res = unhexlify(h.encode('utf8'))

    # Add padding back.
    pad = 0
    for c in s[:-1]:
        if c == B58_DIGITS[0]:
            pad += 1
        else:
            break
    return b'\x00' * pad + res


def encodeBase58(b):
    """Encode bytes to a base58-encoded string"""

    # Convert big-endian bytes to integer
    n = int('0x0' + hexlify(b).decode('utf8'), 16)

    # Divide that integer into bas58
    res = []
    while n > 0:
        n, r = divmod(n, 58)
        res.append(B58_DIGITS[r])
    res = ''.join(res[::-1])

    # Encode leading zeros as base58 zeros
    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 == czero:
            pad += 1
        else:
            break
    return B58_DIGITS[0] * pad + res

def encodeBitcoinAddress(prefix, data):
    data2 = prefix + data
    cksm = hash256(data2)[:4]
    data3 = data2 + cksm
    b58 = encodeBase58(data3)
    return b58


class CompactSize(int):
    def serialize(self):
        assert(self>=0)
        if self<253:
            return struct.pack("<B", self)
        elif self<2**16:
            return struct.pack("<B", 253) + struct.pack("<H", self)
        elif self<2**32:
            return struct.pack("<B", 254) + struct.pack("<I", self)
        elif self<2**64:
            return struct.pack("<B", 255) + struct.pack("<Q", self)

    def deserialize(self, f):
        self = struct.unpack("<B", f.read(1))[0]
        if self == 253:
            self = struct.unpack("<H", f.read(2))[0]
        elif self == 254:
            self = struct.unpack("<I", f.read(4))[0]
        elif self == 255:
            self = struct.unpack("<Q", f.read(8))[0]
        return self

def deser_string(f):
    """Convert an array of bytes in the bitcoin P2P protocol format into a string

    >>> import io
    >>> deser_string(io.BytesIO(ser_string("The grid bug bites!  You get zapped!".encode()))).decode()
    'The grid bug bites!  You get zapped!'
    """
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    return f.read(nit)


def ser_string(s):
    """convert a string into an array of bytes (in the bitcoin network format)

       >>> ser_string("The grid bug bites!  You get zapped!".encode())
       b'$The grid bug bites!  You get zapped!'
    """
    if len(s) < 253:
        return struct.pack("B", len(s)) + s
    elif len(s) < 0x10000:
        return struct.pack("<BH", 253, len(s)) + s
    elif len(s) < 0x100000000:
        return struct.pack("<BI", 254, len(s)) + s
    return struct.pack("<BQ", 255, len(s)) + s


def deser_uint256(f):
    r = 0
    for i in range(8):
        t = struct.unpack("<I", f.read(4))[0]
        r += t << (i * 32)
    return r


def ser_uint256(u):
    rs = b""
    for i in range(8):
        rs += struct.pack("<I", u & 0xFFFFFFFF)
        u >>= 32
    return rs


def uint256_from_str(s):
    r = 0
    t = struct.unpack("<IIIIIIII", s[:32])
    for i in range(8):
        r += t[i] << (i * 32)
    return r

def uint256_from_bigendian(s):
    """Decode a uint256 from a big-endian byte array or hex string (lexical order is big-endian)
    """
    if type(s) is str:
        s = unhexlify(s)
    r = 0
    t = struct.unpack(">QQQQ", s[:32])
    for i in t:
        r = (r << 64) | i
    return r


def uint256_from_compact(c):
    nbytes = (c >> 24) & 0xFF
    v = (c & 0xFFFFFF) << (8 * (nbytes - 3))
    return v


def deser_vector(f, c):
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    r = []
    for i in range(nit):
        t = c()
        t.deserialize(f)
        r.append(t)
    return r


def ser_vector(l):
    r = b""
    if len(l) < 253:
        r = struct.pack("B", len(l))
    elif len(l) < 0x10000:
        r = struct.pack("<BH", 253, len(l))
    elif len(l) < 0x100000000:
        r = struct.pack("<BI", 254, len(l))
    else:
        r = struct.pack("<BQ", 255, len(l))
    for i in l:
        r += i.serialize()
    return r


def deser_uint256_vector(f):
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    r = []
    for i in range(nit):
        t = deser_uint256(f)
        r.append(t)
    return r


def ser_uint256_vector(l):
    r = b""
    if len(l) < 253:
        r = struct.pack("B", len(l))
    elif len(l) < 0x10000:
        r = struct.pack("<BH", 253, len(l))
    elif len(l) < 0x100000000:
        r = struct.pack("<BI", 254, len(l))
    else:
        r = struct.pack("<BQ", 255, len(l))
    for i in l:
        r += ser_uint256(i)
    return r

def ser_compact_size(l):
    r = b""
    if l < 253:
        r = struct.pack("B", l)
    elif l < 0x10000:
        r = struct.pack("<BH", 253, l)
    elif l < 0x100000000:
        r = struct.pack("<BI", 254, l)
    else:
        r = struct.pack("<BQ", 255, l)
    return r

def deser_compact_size(f):
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    return nit

def deser_string_vector(f):
    nit = struct.unpack("<B", f.read(1))[0]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    r = []
    for i in range(nit):
        t = deser_string(f)
        r.append(t)
    return r


def ser_string_vector(l):
    r = b""
    if len(l) < 253:
        r = struct.pack("B", len(l))
    elif len(l) < 0x10000:
        r = struct.pack("<BH", 253, len(l))
    elif len(l) < 0x100000000:
        r = struct.pack("<BI", 254, len(l))
    else:
        r = struct.pack("<BQ", 255, 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]
    if nit == 253:
        nit = struct.unpack("<H", f.read(2))[0]
    elif nit == 254:
        nit = struct.unpack("<I", f.read(4))[0]
    elif nit == 255:
        nit = struct.unpack("<Q", f.read(8))[0]
    r = []
    for i in range(nit):
        t = struct.unpack("<i", f.read(4))[0]
        r.append(t)
    return r


def ser_int_vector(l):
    r = b""
    if len(l) < 253:
        r = struct.pack("B", len(l))
    elif len(l) < 0x10000:
        r = struct.pack("<BH", 253, len(l))
    elif len(l) < 0x100000000:
        r = struct.pack("<BI", 254, len(l))
    else:
        r = struct.pack("<BQ", 255, len(l))
    for i in l:
        r += struct.pack("<i", i)
    return r

# Deserialize from a hex string representation (eg from RPC)


def FromHex(obj, hex_string):
    obj.deserialize(BytesIO(unhexlify(hex_string.encode('ascii'))))
    return obj

# Convert a binary-serializable object to hex (eg for submission via RPC)


def ToHex(obj):
    return hexlify(obj.serialize()).decode('ascii')


# Objects that map to bitcoind objects, which can be serialized/deserialized

# because the nVersion field has not been passed before the VERSION message the protocol uses an old format for the CAddress (missing nTime)
# This class handles that old format
class CAddressInVersion(object):
    def __init__(self, ip="0.0.0.0", port=0):
        self.nServices = 1
        self.pchReserved = b"\x00" * 10 + b"\xff" * 2  # ip is 16 bytes on wire to handle v6
        self.ip = ip
        self.port = port

    def deserialize(self, f):
        self.nServices = struct.unpack("<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]

    def serialize(self):
        r = b""
        r += struct.pack("<Q", self.nServices)
        r += self.pchReserved
        r += socket.inet_aton(self.ip)
        r += struct.pack(">H", self.port)
        return r

    def __repr__(self):
        return "CAddressInVersion(nServices=%i ip=%s port=%i)" % (self.nServices, self.ip, self.port)

# Handle new-style CAddress objects (with nTime)
class CAddress(object):
    def __init__(self, ip="0.0.0.0", port=0):
        self.nServices = 1
        self.nTime = int(time.time())
        self.pchReserved = b"\x00" * 10 + b"\xff" * 2  # ip is 16 bytes on wire to handle v6
        self.ip = ip
        self.port = port

    def deserialize(self, f):
        self.nTime = struct.unpack("<L", f.read(4))[0]
        self.nServices = struct.unpack("<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]

    def serialize(self):
        r = b""
        r += struct.pack("<L", self.nTime)
        r += struct.pack("<Q", self.nServices)
        r += self.pchReserved
        r += socket.inet_aton(self.ip)
        r += struct.pack(">H", self.port)
        return r

    def __repr__(self):
        return "CAddress(nServices=%i ip=%s port=%i time=%d)" % (self.nServices, self.ip, self.port, self.nTime)


class CInv(object):
    MSG_TX = 1
    MSG_BLOCK = 2
    MSG_FILTERED_BLOCK = 3
    MSG_CMPCT_BLOCK = 4
    MSG_XTHINBLOCK = 5
    MSG_THINBLOCK = MSG_CMPCT_BLOCK
    typemap = {
        0: "Error",
        1: "TX",
        2: "Block",
        3: "FilteredBlock",
        4: "CompactBlock",
        5: "XThinBlock",
    }

    def __init__(self, t=0, h=0):
        self.type = t
        self.hash = h

    def deserialize(self, f):
        self.type = struct.unpack("<i", f.read(4))[0]
        self.hash = deser_uint256(f)

    def serialize(self):
        r = b""
        r += struct.pack("<i", self.type)
        r += ser_uint256(self.hash)
        return r

    def __repr__(self):
        return "CInv(type=%s hash=%064x)" \
            % (self.typemap[self.type], self.hash)


class CBlockLocator(object):
    def __init__(self):
        self.nVersion = MY_VERSION
        self.vHave = []

    def deserialize(self, f):
        self.nVersion = struct.unpack("<i", f.read(4))[0]
        self.vHave = deser_uint256_vector(f)

    def serialize(self):
        r = b""
        r += struct.pack("<i", self.nVersion)
        r += ser_uint256_vector(self.vHave)
        return r

    def __repr__(self):
        return "CBlockLocator(nVersion=%i vHave=%s)" \
            % (self.nVersion, repr(self.vHave))


class COutPoint(object):
    def __init__(self, hash=0, n=0):
        if type(hash) is str:
            hash = uint256_from_bigendian(hash)
        if type(hash) is bytes:
            hash = uint256_from_str(hash)
        self.hash = hash
        self.n = n

    def deserialize(self, f):
        self.hash = deser_uint256(f)
        self.n = struct.unpack("<I", f.read(4))[0]

    def serialize(self):
        r = b""
        r += ser_uint256(self.hash)
        r += struct.pack("<I", self.n)
        return r

    def __repr__(self):
        return "COutPoint(hash=%064x n=%i)" % (self.hash, self.n)


class CTxIn(object):
    def __init__(self, outpoint=None, scriptSig=b"", nSequence=0):
        if outpoint is None:
            self.prevout = COutPoint()
        else:
            self.prevout = outpoint
        self.scriptSig = scriptSig
        self.nSequence = nSequence

    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]

    def serialize(self):
        r = b""
        r += self.prevout.serialize()
        r += ser_string(self.scriptSig)
        r += struct.pack("<I", self.nSequence)
        return r

    def __repr__(self):
        return "CTxIn(prevout=%s scriptSig=%s nSequence=%i)" \
            % (repr(self.prevout), hexlify(self.scriptSig),
               self.nSequence)


class CTxOut(object):
    def __init__(self, nValue=0, scriptPubKey=b""):
        self.nValue = nValue
        self.scriptPubKey = scriptPubKey

    def deserialize(self, f):
        self.nValue = struct.unpack("<q", f.read(8))[0]
        self.scriptPubKey = deser_string(f)

    def serialize(self):
        r = b""
        r += struct.pack("<q", int(self.nValue))
        r += ser_string(self.scriptPubKey)
        return r

    def __repr__(self):
        return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" \
            % (self.nValue // COIN, self.nValue % COIN,
               hexlify(self.scriptPubKey))


class CTransaction(object):
    def __init__(self, tx=None):
        if tx is None:
            self.nVersion = 1
            self.vin = []
            self.vout = []
            self.nLockTime = 0
            self.sha256 = None
            self.hash = None
        else:
            self.nVersion = tx.nVersion
            self.vin = copy.deepcopy(tx.vin)
            self.vout = copy.deepcopy(tx.vout)
            self.nLockTime = tx.nLockTime
            self.sha256 = None
            self.hash = None

    def deserialize(self, f):
        if isinstance(f, str):
            # str - assumed to be hex string
            f = BytesIO(unhexlify(f))
        elif isinstance(f, bytes):
            f = BytesIO(f)
        self.nVersion = struct.unpack("<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.sha256 = None
        self.hash = None
        return self

    def serialize(self):
        r = b""
        r += struct.pack("<i", self.nVersion)
        r += ser_vector(self.vin)
        r += ser_vector(self.vout)
        r += struct.pack("<I", self.nLockTime)
        return r

    def toHex(self):
        """Return the hex string serialization of this object"""
        return hexlify(self.serialize()).decode("utf-8")

    def rehash(self):
        self.sha256 = None
        self.calc_sha256()
        return self.hash

    def calc_sha256(self):
        if self.sha256 is None:
            self.sha256 = uint256_from_str(hash256(self.serialize()))
        self.hash = encode(hash256(self.serialize())[::-1], 'hex_codec').decode('ascii')
        return self.hash

    def getHash(self):
        if self.sha256 is None:
            self.rehash()
        return self.sha256

    def is_valid(self):
        self.calc_sha256()
        for tout in self.vout:
            if tout.nValue < 0 or tout.nValue > 21000000 * COIN:
                return False
        return True

    def summary(self):
        self.calc_sha256()
        s = ["Transaction: %064x\n" % self.sha256]
        s.append("%d inputs\n" % len(self.vin))
        for vin in self.vin:
            s.append("  %064x:%d\n" % (vin.prevout.hash, vin.prevout.n))
        s.append("%d outputs\n" % len(self.vout))
        for vout in self.vout:
            s.append("  %12d %s\n" % (vout.nValue, hexlify((vout.scriptPubKey))))
        return "".join(s)

    def __repr__(self):
        return "CTransaction(nVersion=%i vin=%s vout=%s nLockTime=%i)" \
            % (self.nVersion, repr(self.vin), repr(self.vout), self.nLockTime)

    def SignatureHash(self, in_number, scriptCode, nValue, hashcode = SIGHASH_ALL | SIGHASH_FORKID, single = False, debug=False):
        """Calculate hash digest for given input, using SIGHASH_FORKID
        (Bitcoin Cash signing). Returns it in binary, little-endian.

        txin is the corresponding input CTransaction. Supplying it is
        necessary to include the scriptPubKey in the hashed output.

        If single is True, just a single invocation of SHA256 is done,
        instead of the usual, expected double hashing. This is to aid
        applications such as CHECKDATASIG(VERIFY).
        """
        hashdata = struct.pack("<I", self.nVersion)

        h_prevouts = self.hashPrevouts(hashcode)
        if debug:
            print("Hash prevouts:", hexlify(h_prevouts[::-1]))
        hashdata += h_prevouts

        h_sequence = self.hashSequence(hashcode)
        if debug:
            print("Hash sequence:", hexlify(h_sequence[::-1]))

        hashdata += h_sequence
        hashdata += self.vin[in_number].prevout.serialize()


        # FIXME: long scriptPubKeys not supported yet
        assert 75 >= len(scriptCode) > 0
        hashdata += struct.pack("<B", len(scriptCode))
        hashdata += scriptCode
        hashdata += struct.pack("<Q", nValue)
        hashdata += struct.pack("<I", self.vin[in_number].nSequence)

        h_outputs = self.hashOutputs(hashcode, in_number)
        if debug:
            print("Hash outputs:", hexlify(h_outputs[::-1]))
        hashdata += h_outputs
        hashdata += struct.pack("<I", self.nLockTime)
        hashdata += struct.pack("<I", hashcode)

        if debug:
            print("Hash all data:", hexlify(hashdata))
        if single:
            return sha256(hashdata)
        else:
            return hash256(hashdata)

    def hashPrevouts(self, hashcode):
        if hashcode & SIGHASH_ANYONECANPAY:
            return 32 * b"\x00"
        else:
            op_ser = b""
            for inp in self.vin:
                op_ser += inp.prevout.serialize()
            return hash256(op_ser)

    def hashSequence(self, hashcode):
        if (hashcode & SIGHASH_ANYONECANPAY or
            hashcode & 0x1f == SIGHASH_SINGLE or
            hashcode & 0x1f == SIGHASH_NONE):
            return 32 * b"\x00"
        else:
            seq_ser = b""
            for inp in self.vin:
                seq_ser += struct.pack("<I", inp.nSequence)
            return hash256(seq_ser)

    def hashOutputs(self, hashcode, in_number):
        if hashcode & 0x1f == SIGHASH_SINGLE and in_number < len(self.vout):
            return hash256(self.vout[in_number].serialize())
        elif ((not (hashcode & 0x1f == SIGHASH_SINGLE)) and
              (not (hashcode & 0x1f == SIGHASH_NONE))):
            out_ser = b""
            for out in self.vout:
                out_ser += out.serialize()
            return hash256(out_ser)
        else:
            return 32 * b"\x00"

    def SignatureHashLegacy(self, script, inIdx, hashtype):
        """Consensus-correct SignatureHash (legacy variant)

        Returns (hash, err) to precisely match the consensus-critical behavior of
        the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity)
        """
        from .script import FindAndDelete, CScript, OP_CODESEPARATOR

        HASH_ONE = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

        if inIdx >= len(self.vin):
            return (HASH_ONE, "inIdx %d out of range (%d)" % (inIdx, len(self.vin)))

        # create copy as it is going to be modified with FindAndDelete(..)
        txtmp = CTransaction(self)

        for txin in txtmp.vin:
            txin.scriptSig = b''
        txtmp.vin[inIdx].scriptSig = FindAndDelete(script, CScript([OP_CODESEPARATOR]))

        if (hashtype & 0x1f) == SIGHASH_NONE:
            txtmp.vout = []

            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 (HASH_ONE, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout)))

            tmp = txtmp.vout[outIdx]
            txtmp.vout = []
            for i in range(outIdx):
                txtmp.vout.append(CTxOut())
            txtmp.vout.append(tmp)

            for i in range(len(txtmp.vin)):
                if i != inIdx:
                    txtmp.vin[i].nSequence = 0

        if hashtype & SIGHASH_ANYONECANPAY:
            tmp = txtmp.vin[inIdx]
            txtmp.vin = []
            txtmp.vin.append(tmp)

        s = txtmp.serialize()
        s += struct.pack(b"<I", hashtype)

        hash = hash256(s)

        return (hash, None)



class CBlockHeader(object):
    def __init__(self, header=None):
        if header is None:
            self.set_null()
        else:
            self.nVersion = header.nVersion
            self.hashPrevBlock = header.hashPrevBlock
            self.hashMerkleRoot = header.hashMerkleRoot
            self.nTime = header.nTime
            self.nBits = header.nBits
            self.nNonce = header.nNonce
            self.sha256 = header.sha256
            self.hash = header.hash
            self.calc_sha256()

    def set_null(self):
        self.nVersion = 1
        self.hashPrevBlock = 0
        self.hashMerkleRoot = 0
        self.nTime = 0
        self.nBits = 0
        self.nNonce = 0
        self.sha256 = None
        self.hash = None

    def deserialize(self, f):
        self.nVersion = struct.unpack("<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.sha256 = None
        self.hash = None

    def serialize(self):
        r = b""
        r += struct.pack("<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)
        return r

    def calc_sha256(self):
        if self.sha256 is None:
            r = b""
            r += struct.pack("<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)
            self.sha256 = uint256_from_str(hash256(r))
            self.hash = encode(hash256(r)[::-1], 'hex_codec').decode('ascii')
        return self.hash

    def gethashprevblock(self, encoding = 'int'):
        assert encoding == 'hex' or encoding == 'int'
        if encoding == 'int':
            return self.hashPrevBlock
        return hex(self.hashPrevBlock)


    def gethash(self, encoding = 'int'):
        assert encoding == 'hex' or encoding == 'int'
        self.calc_sha256()
        if encoding == 'int':
            return self.sha256
        return hex(self.sha256)

    def rehash(self):
        self.sha256 = None
        self.calc_sha256()
        return self.sha256

    def summary(self):
        s = []
        s.append("Block:  %064x  Time:%s  Version:0x%x Bits:0x%08x\n" %
                 (self.gethash(), time.ctime(self.nTime), self.nVersion, self.nBits))
        s.append("Parent: %064x  Merkle: %064x" % (self.hashPrevBlock, self.hashMerkleRoot))
        return "".join(s)

    def __str__(self):
        return "CBlockHeader(hash=%064x nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)" \
            % (self.gethash(), self.nVersion, self.hashPrevBlock, self.hashMerkleRoot, time.ctime(self.nTime), self.nBits, self.nNonce)

    def __repr__(self):
        return "CBlockHeader(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)" \
            % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
               time.ctime(self.nTime), self.nBits, self.nNonce)


class CBlock(CBlockHeader):
    def __init__(self, header=None):
        super(CBlock, self).__init__(header)
        self.vtx = []

    def deserialize(self, f):
        super(CBlock, self).deserialize(f)
        self.vtx = deser_vector(f, CTransaction)

    def serialize(self):
        r = b""
        r += super(CBlock, self).serialize()
        r += ser_vector(self.vtx)
        return r

    def calc_merkle_root(self):
        hashes = []
        for tx in self.vtx:
            tx.calc_sha256()
            hashes.append(ser_uint256(tx.sha256))
        while len(hashes) > 1:
            newhashes = []
            for i in range(0, len(hashes), 2):
                i2 = min(i + 1, len(hashes) - 1)
                newhashes.append(hash256(hashes[i] + hashes[i2]))
            hashes = newhashes
        if hashes:
            return uint256_from_str(hashes[0])
        return 0

    def is_valid(self):
        self.calc_sha256()
        target = uint256_from_compact(self.nBits)
        if self.sha256 > target:
            return False
        for tx in self.vtx:
            if not tx.is_valid():
                return False
        if self.calc_merkle_root() != self.hashMerkleRoot:
            return False
        return True

    def solve(self):
        self.rehash()
        target = uint256_from_compact(self.nBits)
        while self.sha256 > target:
            self.nNonce += 1
            self.rehash()

    def __str__(self):
        return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx_len=%d)" \
            % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
               time.ctime(self.nTime), self.nBits, self.nNonce, len(self.vtx))

    def __repr__(self):
        return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%s)" \
            % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
               time.ctime(self.nTime), self.nBits, self.nNonce, repr(self.vtx))


class CUnsignedAlert(object):
    def __init__(self):
        self.nVersion = 1
        self.nRelayUntil = 0
        self.nExpiration = 0
        self.nID = 0
        self.nCancel = 0
        self.setCancel = []
        self.nMinVer = 0
        self.nMaxVer = 0
        self.setSubVer = []
        self.nPriority = 0
        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.setCancel = deser_int_vector(f)
        self.nMinVer = struct.unpack("<i", f.read(4))[0]
        self.nMaxVer = struct.unpack("<i", f.read(4))[0]
        self.setSubVer = deser_string_vector(f)
        self.nPriority = struct.unpack("<i", f.read(4))[0]
        self.strComment = deser_string(f)
        self.strStatusBar = deser_string(f)
        self.strReserved = deser_string(f)

    def serialize(self):
        r = b""
        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 += ser_int_vector(self.setCancel)
        r += struct.pack("<i", self.nMinVer)
        r += struct.pack("<i", self.nMaxVer)
        r += ser_string_vector(self.setSubVer)
        r += struct.pack("<i", self.nPriority)
        r += ser_string(self.strComment)
        r += ser_string(self.strStatusBar)
        r += ser_string(self.strReserved)
        return r

    def __repr__(self):
        return "CUnsignedAlert(nVersion %d, nRelayUntil %d, nExpiration %d, nID %d, nCancel %d, nMinVer %d, nMaxVer %d, nPriority %d, strComment %s, strStatusBar %s, strReserved %s)" \
            % (self.nVersion, self.nRelayUntil, self.nExpiration, self.nID,
               self.nCancel, self.nMinVer, self.nMaxVer, self.nPriority,
               self.strComment, self.strStatusBar, self.strReserved)


class CAlert(object):
    def __init__(self):
        self.vchMsg = b""
        self.vchSig = b""

    def deserialize(self, f):
        self.vchMsg = deser_string(f)
        self.vchSig = deser_string(f)

    def serialize(self):
        r = b""
        r += ser_string(self.vchMsg)
        r += ser_string(self.vchSig)
        return r

    def __repr__(self):
        return "CAlert(vchMsg.sz %d, vchSig.sz %d)" \
            % (len(self.vchMsg), len(self.vchSig))


class PrefilledTransaction(object):
    def __init__(self, index=0, tx = None):
        self.index = index
        self.tx = tx

    def deserialize(self, f):
        self.index = deser_compact_size(f)
        self.tx = CTransaction()
        self.tx.deserialize(f)

    def serialize(self):
        r = b""
        r += ser_compact_size(self.index)
        r += self.tx.serialize()
        return r

    def __repr__(self):
        return "PrefilledTransaction(index=%d, tx=%s)" % (self.index, repr(self.tx))

# This is what we send on the wire, in a cmpctblock message.
class P2PHeaderAndShortIDs(object):
    def __init__(self):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids_length = 0
        self.shortids = []
        self.prefilled_txn_length = 0
        self.prefilled_txn = []

    def deserialize(self, f):
        self.header.deserialize(f)
        self.nonce = struct.unpack("<Q", f.read(8))[0]
        self.shortids_length = deser_compact_size(f)
        for i in range(self.shortids_length):
            # shortids are defined to be 6 bytes in the spec, so append
            # two zero bytes and read it in as an 8-byte number
            self.shortids.append(struct.unpack("<Q", f.read(6) + b'\x00\x00')[0])
        self.prefilled_txn = deser_vector(f, PrefilledTransaction)
        self.prefilled_txn_length = len(self.prefilled_txn)

    def serialize(self):
        r = b""
        r += self.header.serialize()
        r += struct.pack("<Q", self.nonce)
        r += ser_compact_size(self.shortids_length)
        for x in self.shortids:
            # We only want the first 6 bytes
            r += struct.pack("<Q", x)[0:6]
        r += ser_vector(self.prefilled_txn)
        return r

    def __repr__(self):
        return "P2PHeaderAndShortIDs(header=%s, nonce=%d, shortids_length=%d, shortids=%s, prefilled_txn_length=%d, prefilledtxn=%s" % (repr(self.header), self.nonce, self.shortids_length, repr(self.shortids), self.prefilled_txn_length, repr(self.prefilled_txn))


# Calculate the BIP 152-compact blocks shortid for a given transaction hash
def calculate_shortid(k0, k1, tx_hash):
    expected_shortid = siphash256(k0, k1, tx_hash)
    expected_shortid &= 0x0000ffffffffffff
    return expected_shortid

# This version gets rid of the array lengths, and reinterprets the differential
# encoding into indices that can be used for lookup.
class HeaderAndShortIDs(object):
    def __init__(self, p2pheaders_and_shortids = None):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids = []
        self.prefilled_txn = []

        if p2pheaders_and_shortids != None:
            self.header = p2pheaders_and_shortids.header
            self.nonce = p2pheaders_and_shortids.nonce
            self.shortids = p2pheaders_and_shortids.shortids
            last_index = -1
            for x in p2pheaders_and_shortids.prefilled_txn:
                self.prefilled_txn.append(PrefilledTransaction(x.index + last_index + 1, x.tx))
                last_index = self.prefilled_txn[-1].index

    def to_p2p(self):
        ret = P2PHeaderAndShortIDs()
        ret.header = self.header
        ret.nonce = self.nonce
        ret.shortids_length = len(self.shortids)
        ret.shortids = self.shortids
        ret.prefilled_txn_length = len(self.prefilled_txn)
        ret.prefilled_txn = []
        last_index = -1
        for x in self.prefilled_txn:
            ret.prefilled_txn.append(PrefilledTransaction(x.index - last_index - 1, x.tx))
            last_index = x.index
        return ret

    def get_siphash_keys(self):
        header_nonce = self.header.serialize()
        header_nonce += struct.pack("<Q", self.nonce)
        hash_header_nonce_as_str = sha256(header_nonce)
        key0 = struct.unpack("<Q", hash_header_nonce_as_str[0:8])[0]
        key1 = struct.unpack("<Q", hash_header_nonce_as_str[8:16])[0]
        return [ key0, key1 ]

    def initialize_from_block(self, block, nonce=0, prefill_list = [0]):
        self.header = CBlockHeader(block)
        self.nonce = nonce
        self.prefilled_txn = [ PrefilledTransaction(i, block.vtx[i]) for i in prefill_list ]
        self.shortids = []
        [k0, k1] = self.get_siphash_keys()
        for i in range(len(block.vtx)):
            if i not in prefill_list:
                self.shortids.append(calculate_shortid(k0, k1, block.vtx[i].sha256))

    def __repr__(self):
        return "HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s" % (repr(self.header), self.nonce, repr(self.shortids), repr(self.prefilled_txn))


class BlockTransactionsRequest(object):

    def __init__(self, blockhash=0, indexes = None):
        self.blockhash = blockhash
        self.indexes = indexes if indexes != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        indexes_length = deser_compact_size(f)
        for i in range(indexes_length):
            self.indexes.append(deser_compact_size(f))

    def serialize(self):
        r = b""
        r += ser_uint256(self.blockhash)
        r += ser_compact_size(len(self.indexes))
        for x in self.indexes:
            r += ser_compact_size(x)
        return r

    # helper to set the differentially encoded indexes from absolute ones
    def from_absolute(self, absolute_indexes):
        self.indexes = []
        last_index = -1
        for x in absolute_indexes:
            self.indexes.append(x-last_index-1)
            last_index = x

    def to_absolute(self):
        absolute_indexes = []
        last_index = -1
        for x in self.indexes:
            absolute_indexes.append(x+last_index+1)
            last_index = absolute_indexes[-1]
        return absolute_indexes

    def __repr__(self):
        return "BlockTransactionsRequest(hash=%064x indexes=%s)" % (self.blockhash, repr(self.indexes))


class BlockTransactions(object):

    def __init__(self, blockhash=0, transactions = None):
        self.blockhash = blockhash
        self.transactions = transactions if transactions != None else []

    def deserialize(self, f):
        self.blockhash = deser_uint256(f)
        self.transactions = deser_vector(f, CTransaction)

    def serialize(self, with_witness=False):
        r = b""
        r += ser_uint256(self.blockhash)
        if with_witness:
            r += ser_vector(self.transactions, "serialize_with_witness")
        else:
            r += ser_vector(self.transactions)
        return r

    def __repr__(self):
        return "BlockTransactions(hash=%064x transactions=%s)" % (self.blockhash, repr(self.transactions))

# Objects that correspond to messages on the wire
class msg_version(object):
    command = b"version"

    def __init__(self):
        self.nVersion = MY_VERSION
        self.nServices = 1
        self.nTime = int(time.time())
        self.addrTo = CAddressInVersion()
        self.addrFrom = CAddressInVersion()
        self.nNonce = random.getrandbits(64)
        self.strSubVer = MY_SUBVERSION
        self.nStartingHeight = -1

    def deserialize(self, f):
        self.nVersion = struct.unpack("<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.addrTo = CAddressInVersion()
        self.addrTo.deserialize(f)
        if self.nVersion >= 106:
            self.addrFrom = CAddressInVersion()
            self.addrFrom.deserialize(f)
            self.nNonce = struct.unpack("<Q", f.read(8))[0]
            self.strSubVer = deser_string(f)
            if self.nVersion >= 209:
                self.nStartingHeight = struct.unpack("<i", f.read(4))[0]
            else:
                self.nStartingHeight = None
        else:
            self.addrFrom = None
            self.nNonce = None
            self.strSubVer = None
            self.nStartingHeight = None

    def serialize(self):
        r = b""
        r += struct.pack("<i", self.nVersion)
        r += struct.pack("<Q", self.nServices)
        r += struct.pack("<q", self.nTime)
        r += self.addrTo.serialize()
        r += self.addrFrom.serialize()
        r += struct.pack("<Q", self.nNonce)
        r += ser_string(self.strSubVer)
        r += struct.pack("<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 = b"verack"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

    def __repr__(self):
        return "msg_verack()"

class msg_extversion(object):
    command = b"extversion"

    def __init__(self, xver = {}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:  # serialize integers in compact format inside the vector
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return "msg_extversion(%s)" % repr(self.xver)

class msg_xupdate(object):
    command = b"xupdate"

    def __init__(self, xver = {}):
        self.xver = xver

    def deserialize(self, f):
        map_size = CompactSize().deserialize(f)
        self.xver = {}
        for i in range(map_size):
            key = CompactSize().deserialize(f)
            val_size = CompactSize().deserialize(f)
            value = f.read(val_size)
            self.xver[key] = value

    def serialize(self):
        res = CompactSize(len(self.xver)).serialize()
        for k, v in self.xver.items():
            res += CompactSize(k).serialize()
            if type(v) is int:  # serialize integers in compact format inside the vector
                v = CompactSize(v).serialize()
            res += CompactSize(len(v)).serialize()
            res += v
        return res

    def __repr__(self):
        return "msg_xupdate(%s)" % repr(self.xver)


class msg_addr(object):
    command = b"addr"

    def __init__(self):
        self.addrs = []

    def deserialize(self, f):
        self.addrs = deser_vector(f, CAddress)

    def serialize(self):
        return ser_vector(self.addrs)

    def __repr__(self):
        return "msg_addr(addrs=%s)" % (repr(self.addrs))


class msg_alert(object):
    command = b"alert"

    def __init__(self):
        self.alert = CAlert()

    def deserialize(self, f):
        self.alert = CAlert()
        self.alert.deserialize(f)

    def serialize(self):
        r = b""
        r += self.alert.serialize()
        return r

    def __repr__(self):
        return "msg_alert(alert=%s)" % (repr(self.alert), )


class msg_inv(object):
    command = b"inv"

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        else:
            self.inv = inv

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return "msg_inv(inv=%s)" % (repr(self.inv))


class msg_getdata(object):
    command = b"getdata"

    def __init__(self, inv=None):
        if inv is None:
            self.inv = []
        elif type(inv) == list:
            self.inv = inv
        else:
            self.inv = [inv]

    def deserialize(self, f):
        self.inv = deser_vector(f, CInv)

    def serialize(self):
        return ser_vector(self.inv)

    def __repr__(self):
        return "msg_getdata(inv=%s)" % (repr(self.inv))


class msg_getblocks(object):
    command = b"getblocks"

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b""
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return "msg_getblocks(locator=%s hashstop=%064x)" \
            % (repr(self.locator), self.hashstop)


class msg_tx(object):
    command = b"tx"

    def __init__(self, tx=CTransaction()):
        self.tx = tx

    def deserialize(self, f):
        self.tx.deserialize(f)

    def serialize(self):
        return self.tx.serialize()

    def __repr__(self):
        return "msg_tx(tx=%s)" % (repr(self.tx))


class msg_block(object):
    command = b"block"

    def __init__(self, block=None):
        if block is None:
            self.block = CBlock()
        else:
            self.block = block

    def deserialize(self, f):
        self.block.deserialize(f)

    def serialize(self):
        return self.block.serialize()

    def __str__(self):
        return "msg_block(block=%s)" % (str(self.block))

    def __repr__(self):
        return "msg_block(block=%s)" % (repr(self.block))


class msg_getaddr(object):
    command = b"getaddr"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

    def __repr__(self):
        return "msg_getaddr()"


class msg_ping(object):
    command = b"ping"

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack("<Q", f.read(8))[0]

    def serialize(self):
        r = b""
        r += struct.pack("<Q", self.nonce)
        return r

    def __repr__(self):
        return "msg_ping(nonce=%08x)" % self.nonce


class msg_pong(object):
    command = b"pong"

    def __init__(self, nonce=0):
        self.nonce = nonce

    def deserialize(self, f):
        self.nonce = struct.unpack("<Q", f.read(8))[0]

    def serialize(self):
        r = b""
        r += struct.pack("<Q", self.nonce)
        return r

    def __repr__(self):
        return "msg_pong(nonce=%08x)" % self.nonce


class msg_mempool(object):
    command = b"mempool"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

    def __repr__(self):
        return "msg_mempool()"


class msg_sendheaders(object):
    command = b"sendheaders"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

    def __repr__(self):
        return "msg_sendheaders()"



class msg_getheaders(object):
    """
    getheaders message has
    locator: CBlockLocator object that identifies what block to start with
    hash_stop: hash of last desired block header, 0 to get as many as possible
    """
    command = b"getheaders"

    def __init__(self):
        self.locator = CBlockLocator()
        self.hashstop = 0

    def deserialize(self, f):
        self.locator = CBlockLocator()
        self.locator.deserialize(f)
        self.hashstop = deser_uint256(f)

    def serialize(self):
        r = b""
        r += self.locator.serialize()
        r += ser_uint256(self.hashstop)
        return r

    def __repr__(self):
        return "msg_getheaders(locator=%s, stop=%064x)" \
            % (repr(self.locator), self.hashstop)


class msg_headers(object):
    """
    headers message has
    <count> <vector of block headers>
    """
    command = b"headers"

    def __init__(self, headers = None):
        self.headers = [] if headers is None else headers

    def deserialize(self, f):
        # comment in bitcoind indicates these should be deserialized as blocks
        blocks = deser_vector(f, CBlock)
        for x in blocks:
            self.headers.append(CBlockHeader(x))

    def serialize(self):
        blocks = [CBlock(x) for x in self.headers]
        return ser_vector(blocks)

    def __repr__(self):
        return "msg_headers(headers=%s)" % repr(self.headers)


class msg_reject(object):
    command = b"reject"
    REJECT_MALFORMED = 1

    def __init__(self):
        self.message = b""
        self.code = 0
        self.reason = b""
        self.data = 0

    def deserialize(self, f):
        self.message = deser_string(f)
        self.code = struct.unpack("<B", f.read(1))[0]
        self.reason = deser_string(f)
        if (self.code != self.REJECT_MALFORMED and
                (self.message == b"block" or self.message == b"tx")):
            self.data = deser_uint256(f)

    def serialize(self):
        r = ser_string(self.message)
        r += struct.pack("<B", self.code)
        r += ser_string(self.reason)
        if (self.code != self.REJECT_MALFORMED and
                (self.message == b"block" or self.message == b"tx")):
            r += ser_uint256(self.data)
        return r

    def __repr__(self):
        return "msg_reject: %s %d %s [%064x]" \
            % (self.message, self.code, self.reason, self.data)

class msg_sendcmpct(object):
    command = b"sendcmpct"

    def __init__(self):
        self.announce = False
        self.version = 1

    def deserialize(self, f):
        self.announce = struct.unpack("<?", f.read(1))[0]
        self.version = struct.unpack("<Q", f.read(8))[0]

    def serialize(self):
        r = b""
        r += struct.pack("<?", self.announce)
        r += struct.pack("<Q", self.version)
        return r

    def __repr__(self):
        return "msg_sendcmpct(announce=%s, version=%lu)" % (self.announce, self.version)

class msg_cmpctblock(object):
    command = b"cmpctblock"

    def __init__(self, header_and_shortids = None):
        self.header_and_shortids = header_and_shortids

    def deserialize(self, f):
        self.header_and_shortids = P2PHeaderAndShortIDs()
        self.header_and_shortids.deserialize(f)

    def serialize(self):
        r = b""
        r += self.header_and_shortids.serialize()
        return r

    def __repr__(self):
        return "msg_cmpctblock(HeaderAndShortIDs=%s)" % repr(self.header_and_shortids)

class msg_getblocktxn(object):
    command = b"getblocktxn"

    def __init__(self):
        self.block_txn_request = None

    def deserialize(self, f):
        self.block_txn_request = BlockTransactionsRequest()
        self.block_txn_request.deserialize(f)

    def serialize(self):
        r = b""
        r += self.block_txn_request.serialize()
        return r

    def __repr__(self):
        return "msg_getblocktxn(block_txn_request=%s)" % (repr(self.block_txn_request))

class msg_blocktxn(object):
    command = b"blocktxn"

    def __init__(self):
        self.block_transactions = BlockTransactions()

    def deserialize(self, f):
        self.block_transactions.deserialize(f)

    def serialize(self):
        r = b""
        r += self.block_transactions.serialize()
        return r

    def __repr__(self):
        return "msg_blocktxn(block_transactions=%s)" % (repr(self.block_transactions))


def Test():
    import doctest
    import sys
    print(doctest.testmod(sys.modules[__name__],verbose=True))

## py.test code
def testCTransactionCopyConstruct():
    a = CTransaction()
    b = CTransaction(a)
