#!/usr/bin/env python3
# Copyright (c) 2010 ArtForz -- public domain half-a-node
# Copyright (c) 2012 Jeff Garzik
# Copyright (c) 2010-2017 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Bitcoin test framework primitive and message structures
CBlock, CTransaction, CBlockHeader, CTxIn, CTxOut, etc....:
    data structures that should map to corresponding structures in
    bitcoin/primitives
msg_block, msg_tx, msg_headers, etc.:
    data structures that represent network messages

ser_*, deser_*: functions that handle serialization/deserialization.

Classes use __slots__ to ensure extraneous attributes aren't accidentally added
by tests, compromising their intended effect.
"""
from codecs import encode
import copy
from collections import namedtuple
import hashlib
from io import BytesIO
import random
import socket
import struct
import time

from test_framework.siphash import siphash256
from test_framework.util import hex_str_to_bytes

import dash_hash

MIN_VERSION_SUPPORTED = 60001
MY_VERSION = 70223  # ADDRV2_PROTO_VERSION
MY_SUBVERSION = b"/python-mininode-tester:0.0.3%s/"
MY_RELAY = 1 # from version 70001 onwards, fRelay should be appended to version messages (BIP37)

MAX_LOCATOR_SZ = 101
MAX_BLOCK_SIZE = 1000000

COIN = 100000000  # 1 btc in satoshis
MAX_MONEY = 21000000 * COIN

BIP125_SEQUENCE_NUMBER = 0xfffffffd  # Sequence number that is BIP 125 opt-in and BIP 68-opt-out

NODE_NETWORK = (1 << 0)
NODE_GETUTXO = (1 << 1)
NODE_BLOOM = (1 << 2)
NODE_COMPACT_FILTERS = (1 << 6)
NODE_NETWORK_LIMITED = (1 << 10)
NODE_HEADERS_COMPRESSED = (1 << 11)

MSG_TX = 1
MSG_BLOCK = 2
MSG_CMPCT_BLOCK = 20
MSG_TYPE_MASK = 0xffffffff >> 2

FILTER_TYPE_BASIC = 0

# Serialization/deserialization tools
def sha256(s):
    return hashlib.new('sha256', s).digest()


def hash256(s):
    return sha256(sha256(s))

def dashhash(s):
    return dash_hash.getPoWHash(s)

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(f):
    nit = deser_compact_size(f)
    return f.read(nit)

def ser_string(s):
    return ser_compact_size(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_to_string(uint256):
    return '%064x' % uint256


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


# deser_function_name: Allow for an alternate deserialization function on the
# entries in the vector.
def deser_vector(f, c, deser_function_name=None):
    nit = deser_compact_size(f)
    r = []
    for i in range(nit):
        t = c()
        if deser_function_name:
            getattr(t, deser_function_name)(f)
        else:
            t.deserialize(f)
        r.append(t)
    return r


# ser_function_name: Allow for an alternate serialization function on the
# entries in the vector (we use this for serializing addrv2 messages).
def ser_vector(l, ser_function_name=None):
    r = ser_compact_size(len(l))
    for i in l:
        if ser_function_name:
            r += getattr(i, ser_function_name)()
        else:
            r += i.serialize()
    return r


def deser_uint256_vector(f):
    nit = deser_compact_size(f)
    r = []
    for i in range(nit):
        t = deser_uint256(f)
        r.append(t)
    return r


def ser_uint256_vector(l):
    r = ser_compact_size(len(l))
    for i in l:
        r += ser_uint256(i)
    return r


def deser_dyn_bitset(f, bytes_based):
    if bytes_based:
        nb = deser_compact_size(f)
        n = nb * 8
    else:
        n = deser_compact_size(f)
        nb = int((n + 7) / 8)
    b = f.read(nb)
    r = []
    for i in range(n):
        r.append((b[int(i / 8)] & (1 << (i % 8))) != 0)
    return r


def ser_dyn_bitset(l, bytes_based):
    n = len(l)
    nb = int((n + 7) / 8)
    r = [0] * nb
    for i in range(n):
        r[int(i / 8)] |= (1 if l[i] else 0) << (i % 8)
    if bytes_based:
        r = ser_compact_size(nb) + bytes(r)
    else:
        r = ser_compact_size(n) + bytes(r)
    return r


# Deserialize from a hex string representation (eg from RPC)
def FromHex(obj, hex_string):
    obj.deserialize(BytesIO(hex_str_to_bytes(hex_string)))
    return obj

# Convert a binary-serializable object to hex (eg for submission via RPC)
def ToHex(obj):
    return obj.serialize().hex()

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

class CService:
    __slots__ = ("ip", "port")

    def __init__(self):
        self.ip = ""
        self.port = 0

    def deserialize(self, f):
        self.ip = socket.inet_ntop(socket.AF_INET6, f.read(16))
        self.port = struct.unpack(">H", f.read(2))[0]

    def serialize(self):
        r = b""
        r += socket.inet_pton(socket.AF_INET6, self.ip)
        r += struct.pack(">H", self.port)
        return r

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


class CAddress:
    __slots__ = ("net", "ip", "nServices", "port", "time")

    # see https://github.com/bitcoin/bips/blob/master/bip-0155.mediawiki
    NET_IPV4 = 1

    ADDRV2_NET_NAME = {
        NET_IPV4: "IPv4"
    }

    ADDRV2_ADDRESS_LENGTH = {
        NET_IPV4: 4
    }

    def __init__(self):
        self.time = 0
        self.nServices = 1
        self.net = self.NET_IPV4
        self.ip = "0.0.0.0"
        self.port = 0

    def deserialize(self, f, with_time=True):
        """Deserialize from addrv1 format (pre-BIP155)"""
        if with_time:
            # VERSION messages serialize CAddress objects without time
            self.time = struct.unpack("<I", f.read(4))[0]
        self.nServices = struct.unpack("<Q", f.read(8))[0]
        # We only support IPv4 which means skip 12 bytes and read the next 4 as IPv4 address.
        f.read(12)
        self.net = self.NET_IPV4
        self.ip = socket.inet_ntoa(f.read(4))
        self.port = struct.unpack(">H", f.read(2))[0]

    def serialize(self, with_time=True):
        """Serialize in addrv1 format (pre-BIP155)"""
        assert self.net == self.NET_IPV4
        r = b""
        if with_time:
            # VERSION messages serialize CAddress objects without time
            r += struct.pack("<I", self.time)
        r += struct.pack("<Q", self.nServices)
        r += b"\x00" * 10 + b"\xff" * 2
        r += socket.inet_aton(self.ip)
        r += struct.pack(">H", self.port)
        return r

    def deserialize_v2(self, f):
        """Deserialize from addrv2 format (BIP155)"""
        self.time = struct.unpack("<I", f.read(4))[0]

        self.nServices = deser_compact_size(f)

        self.net = struct.unpack("B", f.read(1))[0]
        assert self.net == self.NET_IPV4

        address_length = deser_compact_size(f)
        assert address_length == self.ADDRV2_ADDRESS_LENGTH[self.net]

        self.ip = socket.inet_ntoa(f.read(4))

        self.port = struct.unpack(">H", f.read(2))[0]

    def serialize_v2(self):
        """Serialize in addrv2 format (BIP155)"""
        assert self.net == self.NET_IPV4
        r = b""
        r += struct.pack("<I", self.time)
        r += ser_compact_size(self.nServices)
        r += struct.pack("B", self.net)
        r += ser_compact_size(self.ADDRV2_ADDRESS_LENGTH[self.net])
        r += socket.inet_aton(self.ip)
        r += struct.pack(">H", self.port)
        return r

    def __repr__(self):
        return ("CAddress(nServices=%i net=%s addr=%s port=%i)"
                % (self.nServices, self.ADDRV2_NET_NAME[self.net], self.ip, self.port))


class CInv:
    __slots__ = ("hash", "type")

    typemap = {
        0: "Error",
        1: "TX",
        2: "Block",
        20: "CompactBlock"
    }

    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.get(self.type, "%d" % self.type), self.hash)


class CBlockLocator:
    __slots__ = ("nVersion", "vHave")

    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:
    __slots__ = ("hash", "n")

    def __init__(self, hash=0, n=0xFFFFFFFF):
        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:
    __slots__ = ("nSequence", "prevout", "scriptSig")

    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), self.scriptSig.hex(),
                  self.nSequence)


class CTxOut:
    __slots__ = ("nValue", "scriptPubKey")

    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", 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,
                  self.scriptPubKey.hex())


class CTransaction:
    __slots__ = ("hash", "nLockTime", "nVersion", "sha256", "vin", "vout",
                 "nType", "vExtraPayload")

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

    def deserialize(self, f):
        ver32bit = struct.unpack("<i", f.read(4))[0]
        self.nVersion = ver32bit & 0xffff
        self.nType = (ver32bit >> 16) & 0xffff
        self.vin = deser_vector(f, CTxIn)
        self.vout = deser_vector(f, CTxOut)
        self.nLockTime = struct.unpack("<I", f.read(4))[0]
        if self.nType != 0:
            self.vExtraPayload = deser_string(f)
        self.sha256 = None
        self.hash = None

    def serialize(self):
        r = b""
        ver32bit = int(self.nVersion | (self.nType << 16))
        r += struct.pack("<i", ver32bit)
        r += ser_vector(self.vin)
        r += ser_vector(self.vout)
        r += struct.pack("<I", self.nLockTime)
        if self.nType != 0:
            r += ser_string(self.vExtraPayload)
        return r

    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')

    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 __repr__(self):
        return "CTransaction(nVersion=%i vin=%s vout=%s nLockTime=%i)" \
               % (self.nVersion, repr(self.vin), repr(self.vout), self.nLockTime)


class CBlockHeader:
    __slots__ = ("hash", "hashMerkleRoot", "hashPrevBlock", "nBits", "nNonce",
                 "nTime", "nVersion", "sha256")

    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(dashhash(r))
            self.hash = encode(dashhash(r)[::-1], 'hex_codec').decode('ascii')

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

    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):
    __slots__ = ("vtx",)

    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

    # Calculate the merkle root given a vector of transaction hashes
    @staticmethod
    def get_merkle_root(hashes):
        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
        return uint256_from_str(hashes[0])

    def calc_merkle_root(self):
        hashes = []
        for tx in self.vtx:
            tx.calc_sha256()
            hashes.append(ser_uint256(tx.sha256))
        return self.get_merkle_root(hashes)

    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 __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 CompressibleBlockHeader:
    __slots__ = ("bitfield", "timeOffset", "nVersion", "hashPrevBlock", "hashMerkleRoot", "nTime", "nBits", "nNonce",
                 "hash", "sha256")

    FLAG_VERSION_BIT_0 = 1 << 0
    FLAG_VERSION_BIT_1 = 1 << 1
    FLAG_VERSION_BIT_2 = 1 << 2
    FLAG_PREV_BLOCK_HASH = 1 << 3
    FLAG_TIMESTAMP = 1 << 4
    FLAG_NBITS = 1 << 5

    BITMASK_VERSION = FLAG_VERSION_BIT_0 | FLAG_VERSION_BIT_1 | FLAG_VERSION_BIT_2

    def __init__(self, header=None):
        if header is None:
            self.set_null()
        else:
            self.bitfield = 0
            self.timeOffset = 0
            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.hash = None
            self.sha256 = None
            self.calc_sha256()

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

    def deserialize(self, f):
        self.bitfield = struct.unpack("<B", f.read(1))[0]
        if self.bitfield & self.BITMASK_VERSION == 0:
            self.nVersion = struct.unpack("<i", f.read(4))[0]
        if self.bitfield & self.FLAG_PREV_BLOCK_HASH:
            self.hashPrevBlock = deser_uint256(f)
        self.hashMerkleRoot = deser_uint256(f)
        if self.bitfield & self.FLAG_TIMESTAMP:
            self.nTime = struct.unpack("<I", f.read(4))[0]
        else:
            self.timeOffset = struct.unpack("<h", f.read(2))[0]
        if self.bitfield & self.FLAG_NBITS:
            self.nBits = struct.unpack("<I", f.read(4))[0]
        self.nNonce = struct.unpack("<I", f.read(4))[0]
        self.rehash()

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.bitfield)
        if not self.bitfield & self.BITMASK_VERSION:
            r += struct.pack("<i", self.nVersion)
        if self.bitfield & self.FLAG_PREV_BLOCK_HASH:
            r += ser_uint256(self.hashPrevBlock)
        r += ser_uint256(self.hashMerkleRoot)
        r += struct.pack("<I", self.nTime) if self.bitfield & self.FLAG_TIMESTAMP else struct.pack("<h", self.timeOffset)
        if self.bitfield & self.FLAG_NBITS:
            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(dashhash(r))
            self.hash = int(encode(dashhash(r)[::-1], 'hex_codec'), 16)

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

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

    def __save_version_as_most_recent(self, last_unique_versions):
        last_unique_versions.insert(0, self.nVersion)

        # Evict the oldest version
        if len(last_unique_versions) > 7:
            last_unique_versions.pop()

    @staticmethod
    def __mark_version_as_most_recent(last_unique_versions, version_idx):
        # Move version to the front of the list
        last_unique_versions.insert(0, last_unique_versions.pop(version_idx))

    def compress(self, last_blocks, last_unique_versions):
        if not last_blocks:
            # First block, everything must be uncompressed
            self.bitfield &= (~CompressibleBlockHeader.BITMASK_VERSION)
            self.bitfield |= CompressibleBlockHeader.FLAG_PREV_BLOCK_HASH
            self.bitfield |= CompressibleBlockHeader.FLAG_TIMESTAMP
            self.bitfield |= CompressibleBlockHeader.FLAG_NBITS
            self.__save_version_as_most_recent(last_unique_versions)
            return

        # Compress version
        try:
            version_idx = last_unique_versions.index(self.nVersion)
            version_offset = len(last_unique_versions) - version_idx
            self.bitfield &= (~CompressibleBlockHeader.BITMASK_VERSION)
            self.bitfield |= (version_offset & CompressibleBlockHeader.BITMASK_VERSION)
            self.__mark_version_as_most_recent(last_unique_versions, version_idx)
        except ValueError:
            self.__save_version_as_most_recent(last_unique_versions)

        # We have the previous block
        last_block = last_blocks[-1]

        # Compress time
        self.timeOffset = self.nTime - last_block.nTime
        if self.timeOffset > 32767 or self.timeOffset < -32768:
            # Time diff overflows, we have to send it as 4 bytes (uncompressed)
            self.bitfield |= CompressibleBlockHeader.FLAG_TIMESTAMP

        # If nBits doesn't match previous block, we have to send it
        if self.nBits != last_block.nBits:
            self.bitfield |= CompressibleBlockHeader.FLAG_NBITS

    def uncompress(self, last_compressed_blocks, last_unique_versions):
        if not last_compressed_blocks:
            # First block header is always uncompressed
            self.__save_version_as_most_recent(last_unique_versions)
            return

        previous_block = last_compressed_blocks[-1]

        # Uncompress version
        version_idx = self.bitfield & self.BITMASK_VERSION
        if version_idx != 0:
            if version_idx <= len(last_unique_versions):
                self.nVersion = last_unique_versions[version_idx - 1]
                self.__mark_version_as_most_recent(last_unique_versions, version_idx - 1)
        else:
            self.__save_version_as_most_recent(last_unique_versions)

        # Uncompress prev block hash
        if not self.bitfield & self.FLAG_PREV_BLOCK_HASH:
            self.hashPrevBlock = previous_block.hash

        # Uncompress time
        if not self.bitfield & self.FLAG_TIMESTAMP:
            self.nTime = previous_block.nTime + self.timeOffset

        # Uncompress time bits
        if not self.bitfield & self.FLAG_NBITS:
            self.nBits = previous_block.nBits

        self.rehash()


class PrefilledTransaction:
    __slots__ = ("index", "tx")

    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:
    __slots__ = ("header", "nonce", "prefilled_txn", "prefilled_txn_length",
                 "shortids", "shortids_length")

    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:
    __slots__ = ("header", "nonce", "prefilled_txn", "shortids")

    def __init__(self, p2pheaders_and_shortids = None):
        self.header = CBlockHeader()
        self.nonce = 0
        self.shortids = []
        self.prefilled_txn = []

        if p2pheaders_and_shortids is not 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:
    __slots__ = ("blockhash", "indexes")

    def __init__(self, blockhash=0, indexes = None):
        self.blockhash = blockhash
        self.indexes = indexes if indexes is not 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:
    __slots__ = ("blockhash", "transactions")

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

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

    def serialize(self):
        r = b""
        r += ser_uint256(self.blockhash)
        r += ser_vector(self.transactions)
        return r

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


class CPartialMerkleTree:
    __slots__ = ("nTransactions", "vBits", "vHash")

    def __init__(self):
        self.nTransactions = 0
        self.vBits = []
        self.vHash = []

    def deserialize(self, f):
        self.nTransactions = struct.unpack("<I", f.read(4))[0]
        self.vHash = deser_uint256_vector(f)
        self.vBits = deser_dyn_bitset(f, True)

    def serialize(self):
        r = b""
        r += struct.pack("<I", self.nTransactions)
        r += ser_uint256_vector(self.vHash)
        r += ser_dyn_bitset(self.vBits, True)
        return r

    def __repr__(self):
        return "CPartialMerkleTree(nTransactions=%d vBits.size=%d vHash.size=%d)" % (self.nTransactions, len(self.vBits), len(self.vHash))


class CMerkleBlock:
    __slots__ = ("header", "txn")

    def __init__(self, header=CBlockHeader(), txn=CPartialMerkleTree()):
        self.header = header
        self.txn = txn

    def deserialize(self, f):
        self.header.deserialize(f)
        self.txn.deserialize(f)

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

    def __repr__(self):
        return "CMerkleBlock(header=%s txn=%s)" % (repr(self.header), repr(self.txn))


class CCbTx:
    __slots__ = ("version", "height", "merkleRootMNList", "merkleRootQuorums")

    def __init__(self, version=None, height=None, merkleRootMNList=None, merkleRootQuorums=None):
        self.set_null()
        if version is not None:
            self.version = version
        if height is not None:
            self.height = height
        if merkleRootMNList is not None:
            self.merkleRootMNList = merkleRootMNList
        if merkleRootQuorums is not None:
            self.merkleRootQuorums = merkleRootQuorums

    def set_null(self):
        self.version = 0
        self.height = 0
        self.merkleRootMNList = None

    def deserialize(self, f):
        self.version = struct.unpack("<H", f.read(2))[0]
        self.height = struct.unpack("<i", f.read(4))[0]
        self.merkleRootMNList = deser_uint256(f)
        if self.version >= 2:
            self.merkleRootQuorums = deser_uint256(f)

    def serialize(self):
        r = b""
        r += struct.pack("<H", self.version)
        r += struct.pack("<i", self.height)
        r += ser_uint256(self.merkleRootMNList)
        if self.version >= 2:
            r += ser_uint256(self.merkleRootQuorums)
        return r


class CSimplifiedMNListEntry:
    __slots__ = ("proRegTxHash", "confirmedHash", "service", "pubKeyOperator", "keyIDVoting", "isValid")

    def __init__(self):
        self.set_null()

    def set_null(self):
        self.proRegTxHash = 0
        self.confirmedHash = 0
        self.service = CService()
        self.pubKeyOperator = b'\x00' * 48
        self.keyIDVoting = 0
        self.isValid = False

    def deserialize(self, f):
        self.proRegTxHash = deser_uint256(f)
        self.confirmedHash = deser_uint256(f)
        self.service.deserialize(f)
        self.pubKeyOperator = f.read(48)
        self.keyIDVoting = f.read(20)
        self.isValid = struct.unpack("<?", f.read(1))[0]

    def serialize(self):
        r = b""
        r += ser_uint256(self.proRegTxHash)
        r += ser_uint256(self.confirmedHash)
        r += self.service.serialize()
        r += self.pubKeyOperator
        r += self.keyIDVoting
        r += struct.pack("<?", self.isValid)
        return r


class CFinalCommitment:
    __slots__ = ("nVersion", "llmqType", "quorumHash", "quorumIndex", "signers", "validMembers", "quorumPublicKey",
                 "quorumVvecHash", "quorumSig", "membersSig")

    def __init__(self):
        self.set_null()

    def set_null(self):
        self.nVersion = 0
        self.llmqType = 0
        self.quorumHash = 0
        self.quorumIndex = 0
        self.signers = []
        self.validMembers = []
        self.quorumPublicKey = b'\x00' * 48
        self.quorumVvecHash = 0
        self.quorumSig = b'\x00' * 96
        self.membersSig = b'\x00' * 96

    def deserialize(self, f):
        self.nVersion = struct.unpack("<H", f.read(2))[0]
        self.llmqType = struct.unpack("<B", f.read(1))[0]
        self.quorumHash = deser_uint256(f)
        if self.nVersion == 2 or self.nVersion == 4:
            self.quorumIndex = struct.unpack("<H", f.read(2))[0]
        self.signers = deser_dyn_bitset(f, False)
        self.validMembers = deser_dyn_bitset(f, False)
        self.quorumPublicKey = f.read(48)
        self.quorumVvecHash = deser_uint256(f)
        self.quorumSig = f.read(96)
        self.membersSig = f.read(96)

    def serialize(self):
        r = b""
        r += struct.pack("<H", self.nVersion)
        r += struct.pack("<B", self.llmqType)
        r += ser_uint256(self.quorumHash)
        if self.nVersion == 2 or self.nVersion == 4:
            r += struct.pack("<H", self.quorumIndex)
        r += ser_dyn_bitset(self.signers, False)
        r += ser_dyn_bitset(self.validMembers, False)
        r += self.quorumPublicKey
        r += ser_uint256(self.quorumVvecHash)
        r += self.quorumSig
        r += self.membersSig
        return r

    def __repr__(self):
        return "CFinalCommitment(nVersion={} llmqType={} quorumHash={:x} quorumIndex={} signers={}" \
               " validMembers={} quorumPublicKey={} quorumVvecHash={:x}) quorumSig={} membersSig={})" \
            .format(self.nVersion, self.llmqType, self.quorumHash, self.quorumIndex, repr(self.signers),
                    repr(self.validMembers), self.quorumPublicKey.hex(), self.quorumVvecHash, self.quorumSig.hex(), self.membersSig.hex())

class CGovernanceObject:
    __slots__ = ("nHashParent", "nRevision", "nTime", "nCollateralHash", "vchData", "nObjectType",
                 "masternodeOutpoint", "vchSig")

    def __init__(self):
        self.nHashParent = 0
        self.nRevision = 0
        self.nTime = 0
        self.nCollateralHash = 0
        self.vchData = []
        self.nObjectType = 0
        self.masternodeOutpoint = COutPoint()
        self.vchSig = []

    def deserialize(self, f):
        self.nHashParent = deser_uint256(f)
        self.nRevision = struct.unpack("<i", f.read(4))[0]
        self.nTime = struct.unpack("<q", f.read(8))[0]
        self.nCollateralHash = deser_uint256(f)
        size = deser_compact_size(f)
        if size > 0:
            self.vchData = f.read(size)
        self.nObjectType = struct.unpack("<i", f.read(4))[0]
        self.masternodeOutpoint.deserialize(f)
        size = deser_compact_size(f)
        if size > 0:
            self.vchSig = f.read(size)

    def serialize(self):
        r = b""
        r += ser_uint256(self.nParentHash)
        r += struct.pack("<i", self.nRevision)
        r += struct.pack("<q", self.nTime)
        r += deser_uint256(self.nCollateralHash)
        r += deser_compact_size(len(self.vchData))
        r += self.vchData
        r += struct.pack("<i", self.nObjectType)
        r += self.masternodeOutpoint.serialize()
        r += deser_compact_size(len(self.vchSig))
        r += self.vchSig
        return r


class CGovernanceVote:
    __slots__ = ("masternodeOutpoint", "nParentHash", "nVoteOutcome", "nVoteSignal", "nTime", "vchSig")

    def __init__(self):
        self.masternodeOutpoint = COutPoint()
        self.nParentHash = 0
        self.nVoteOutcome = 0
        self.nVoteSignal = 0
        self.nTime = 0
        self.vchSig = []

    def deserialize(self, f):
        self.masternodeOutpoint.deserialize(f)
        self.nParentHash = deser_uint256(f)
        self.nVoteOutcome = struct.unpack("<i", f.read(4))[0]
        self.nVoteSignal = struct.unpack("<i", f.read(4))[0]
        self.nTime = struct.unpack("<q", f.read(8))[0]
        size = deser_compact_size(f)
        if size > 0:
            self.vchSig = f.read(size)

    def serialize(self):
        r = b""
        r += self.masternodeOutpoint.serialize()
        r += ser_uint256(self.nParentHash)
        r += struct.pack("<i", self.nVoteOutcome)
        r += struct.pack("<i", self.nVoteSignal)
        r += struct.pack("<q", self.nTime)
        r += ser_compact_size(len(self.vchSig))
        r += self.vchSig
        return r


class CRecoveredSig:
    __slots__ = ("llmqType", "quorumHash", "id", "msgHash", "sig")

    def __init__(self):
        self.llmqType = 0
        self.quorumHash = 0
        self.id = 0
        self.msgHash = 0
        self.sig = b'\x00' * 96

    def deserialize(self, f):
        self.llmqType = struct.unpack("<B", f.read(1))[0]
        self.quorumHash = deser_uint256(f)
        self.id = deser_uint256(f)
        self.msgHash = deser_uint256(f)
        self.sig = f.read(96)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.llmqType)
        r += ser_uint256(self.quorumHash)
        r += ser_uint256(self.id)
        r += ser_uint256(self.msgHash)
        r += self.sig
        return r


class CSigShare:
    __slots__ = ("llmqType", "quorumHash", "quorumMember", "id", "msgHash", "sigShare")

    def __init__(self):
        self.llmqType = 0
        self.quorumHash = 0
        self.quorumMember = 0
        self.id = 0
        self.msgHash = 0
        self.sigShare = b'\x00' * 96

    def deserialize(self, f):
        self.llmqType = struct.unpack("<B", f.read(1))[0]
        self.quorumHash = deser_uint256(f)
        self.quorumMember = struct.unpack("<H", f.read(2))[0]
        self.id = deser_uint256(f)
        self.msgHash = deser_uint256(f)
        self.sigShare = f.read(96)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.llmqType)
        r += ser_uint256(self.quorumHash)
        r += struct.pack("<H", self.quorumMember)
        r += ser_uint256(self.id)
        r += ser_uint256(self.msgHash)
        r += self.sigShare
        return r


class CBLSPublicKey:
    __slots__ = ("data")

    def __init__(self):
        self.data = b'\x00' * 48

    def deserialize(self, f):
        self.data = f.read(48)

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


class CBLSIESEncryptedSecretKey:
    __slots__ = ("ephemeral_pubKey", "iv", "data")

    def __init__(self):
        self.ephemeral_pubKey = b'\x00' * 48
        self.iv = b'\x00' * 32
        self.data = b'\x00' * 32

    def deserialize(self, f):
        self.ephemeral_pubKey = f.read(48)
        self.iv = f.read(32)
        data_size = deser_compact_size(f)
        self.data = f.read(data_size)

    def serialize(self):
        r = b""
        r += self.ephemeral_pubKey
        r += self.iv
        r += ser_compact_size(len(self.data))
        r += self.data
        return r


# Objects that correspond to messages on the wire
class msg_version:
    __slots__ = ("addrFrom", "addrTo", "nNonce", "nRelay", "nServices",
                 "nStartingHeight", "nTime", "nVersion", "strSubVer")
    command = b"version"

    def __init__(self):
        self.nVersion = MY_VERSION
        self.nServices = 1
        self.nTime = int(time.time())
        self.addrTo = CAddress()
        self.addrFrom = CAddress()
        self.nNonce = random.getrandbits(64)
        self.strSubVer = MY_SUBVERSION % b""
        self.nStartingHeight = -1
        self.nRelay = MY_RELAY

    def deserialize(self, f):
        self.nVersion = struct.unpack("<i", f.read(4))[0]
        self.nServices = struct.unpack("<Q", f.read(8))[0]
        self.nTime = struct.unpack("<q", f.read(8))[0]
        self.addrTo = CAddress()
        self.addrTo.deserialize(f, False)

        self.addrFrom = CAddress()
        self.addrFrom.deserialize(f, False)
        self.nNonce = struct.unpack("<Q", f.read(8))[0]
        self.strSubVer = deser_string(f)

        self.nStartingHeight = struct.unpack("<i", f.read(4))[0]

        if self.nVersion >= 70001:
            # Relay field is optional for version 70001 onwards
            try:
                self.nRelay = struct.unpack("<b", f.read(1))[0]
            except:
                self.nRelay = 0
        else:
            self.nRelay = 0

    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(False)
        r += self.addrFrom.serialize(False)
        r += struct.pack("<Q", self.nNonce)
        r += ser_string(self.strSubVer)
        r += struct.pack("<i", self.nStartingHeight)
        r += struct.pack("<b", self.nRelay)
        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 nRelay=%i)' \
               % (self.nVersion, self.nServices, time.ctime(self.nTime),
                  repr(self.addrTo), repr(self.addrFrom), self.nNonce,
                  self.strSubVer, self.nStartingHeight, self.nRelay)


class msg_verack:
    __slots__ = ()
    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_addr:
    __slots__ = ("addrs",)
    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_addrv2:
    __slots__ = ("addrs",)
    # msgtype = b"addrv2"
    command = b"addrv2"

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

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

    def serialize(self):
        return ser_vector(self.addrs, "serialize_v2")

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


class msg_sendaddrv2:
    __slots__ = ()
    # msgtype = b"sendaddrv2"
    command = b"sendaddrv2"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

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


class msg_inv:
    __slots__ = ("inv",)
    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:
    __slots__ = ("inv",)
    command = b"getdata"

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

    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:
    __slots__ = ("locator", "hashstop")
    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:
    __slots__ = ("tx",)
    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:
    __slots__ = ("block",)
    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 __repr__(self):
        return "msg_block(block=%s)" % (repr(self.block))

# for cases where a user needs tighter control over what is sent over the wire
# note that the user must supply the name of the command, and the data
class msg_generic:
    __slots__ = ("command", "data")

    def __init__(self, command, data=None):
        self.command = command
        self.data = data

    def serialize(self):
        return self.data

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


class msg_getaddr:
    __slots__ = ()
    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:
    __slots__ = ("nonce",)
    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:
    __slots__ = ("nonce",)
    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:
    __slots__ = ()
    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_notfound:
    __slots__ = ("vec", )
    command = b"notfound"

    def __init__(self, vec=None):
        self.vec = vec or []

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

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

    def __repr__(self):
        return "msg_notfound(vec=%s)" % (repr(self.vec))


class msg_sendheaders:
    __slots__ = ()
    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_sendheaders2:
    __slots__ = ()
    command = b"sendheaders2"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

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


# getheaders message has
# number of entries
# vector of hashes
# hash_stop (hash of last desired block header, 0 to get as many as possible)
class msg_getheaders:
    __slots__ = ("hashstop", "locator",)
    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)


# same as msg_getheaders, but to request the headers compressed
class msg_getheaders2:
    __slots__ = ("hashstop", "locator",)
    command = b"getheaders2"

    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_getheaders2(locator=%s, stop=%064x)" \
               % (repr(self.locator), self.hashstop)


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

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

    def deserialize(self, f):
        # comment in dashd 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)


# headers message has
# <count> <vector of compressed block headers>
class msg_headers2:
    __slots__ = ("headers",)
    command = b"headers2"

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

    def deserialize(self, f):
        self.headers = deser_vector(f, CompressibleBlockHeader)
        last_unique_versions = []
        for idx in range(len(self.headers)):
            self.headers[idx].uncompress(self.headers[:idx], last_unique_versions)

    def serialize(self):
        last_unique_versions = []
        for idx in range(len(self.headers)):
            self.headers[idx].compress(self.headers[:idx], last_unique_versions)
        return ser_vector(self.headers)

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


class msg_sendcmpct:
    __slots__ = ("announce", "version")
    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:
    __slots__ = ("header_and_shortids",)
    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:
    __slots__ = ("block_txn_request",)
    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:
    __slots__ = ("block_transactions",)
    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))


class msg_getmnlistd:
    __slots__ = ("baseBlockHash", "blockHash",)
    command = b"getmnlistd"

    def __init__(self, baseBlockHash=0, blockHash=0):
        self.baseBlockHash = baseBlockHash
        self.blockHash = blockHash

    def deserialize(self, f):
        self.baseBlockHash = deser_uint256(f)
        self.blockHash = deser_uint256(f)

    def serialize(self):
        r = b""
        r += ser_uint256(self.baseBlockHash)
        r += ser_uint256(self.blockHash)
        return r

    def __repr__(self):
        return "msg_getmnlistd(baseBlockHash=%064x, blockHash=%064x)" % (self.baseBlockHash, self.blockHash)

QuorumId = namedtuple('QuorumId', ['llmqType', 'quorumHash'])

class msg_mnlistdiff:
    __slots__ = ("baseBlockHash", "blockHash", "merkleProof", "cbTx", "deletedMNs", "mnList", "deletedQuorums", "newQuorums",)
    command = b"mnlistdiff"

    def __init__(self):
        self.baseBlockHash = 0
        self.blockHash = 0
        self.merkleProof = CPartialMerkleTree()
        self.cbTx = None
        self.deletedMNs = []
        self.mnList = []
        self.deletedQuorums = []
        self.newQuorums = []

    def deserialize(self, f):
        self.baseBlockHash = deser_uint256(f)
        self.blockHash = deser_uint256(f)
        self.merkleProof.deserialize(f)
        self.cbTx = CTransaction()
        self.cbTx.deserialize(f)
        self.cbTx.rehash()
        self.deletedMNs = deser_uint256_vector(f)
        self.mnList = []
        for i in range(deser_compact_size(f)):
            e = CSimplifiedMNListEntry()
            e.deserialize(f)
            self.mnList.append(e)

        self.deletedQuorums = []
        for i in range(deser_compact_size(f)):
            llmqType = struct.unpack("<B", f.read(1))[0]
            quorumHash = deser_uint256(f)
            self.deletedQuorums.append(QuorumId(llmqType, quorumHash))
        self.newQuorums = []
        for i in range(deser_compact_size(f)):
            qc = CFinalCommitment()
            qc.deserialize(f)
            self.newQuorums.append(qc)

    def __repr__(self):
        return "msg_mnlistdiff(baseBlockHash=%064x, blockHash=%064x)" % (self.baseBlockHash, self.blockHash)


class msg_clsig:
    __slots__ = ("height", "blockHash", "sig",)
    command = b"clsig"

    def __init__(self, height=0, blockHash=0, sig=b'\x00' * 96):
        self.height = height
        self.blockHash = blockHash
        self.sig = sig

    def deserialize(self, f):
        self.height = struct.unpack('<i', f.read(4))[0]
        self.blockHash = deser_uint256(f)
        self.sig = f.read(96)

    def serialize(self):
        r = b""
        r += struct.pack('<i', self.height)
        r += ser_uint256(self.blockHash)
        r += self.sig
        return r

    def __repr__(self):
        return "msg_clsig(height=%d, blockHash=%064x)" % (self.height, self.blockHash)


class msg_islock:
    __slots__ = ("inputs", "txid", "sig",)
    command = b"islock"

    def __init__(self, inputs=[], txid=0, sig=b'\x00' * 96):
        self.inputs = inputs
        self.txid = txid
        self.sig = sig

    def deserialize(self, f):
        self.inputs = deser_vector(f, COutPoint)
        self.txid = deser_uint256(f)
        self.sig = f.read(96)

    def serialize(self):
        r = b""
        r += ser_vector(self.inputs)
        r += ser_uint256(self.txid)
        r += self.sig
        return r

    def __repr__(self):
        return "msg_islock(inputs=%s, txid=%064x)" % (repr(self.inputs), self.txid)


class msg_isdlock:
    __slots__ = ("nVersion", "inputs", "txid", "cycleHash", "sig")
    command = b"isdlock"

    def __init__(self, nVersion=1, inputs=[], txid=0, cycleHash=0, sig=b'\x00' * 96):
        self.nVersion = nVersion
        self.inputs = inputs
        self.txid = txid
        self.cycleHash = cycleHash
        self.sig = sig

    def deserialize(self, f):
        self.nVersion = struct.unpack("<B", f.read(1))[0]
        self.inputs = deser_vector(f, COutPoint)
        self.txid = deser_uint256(f)
        self.cycleHash = deser_uint256(f)
        self.sig = f.read(96)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.nVersion)
        r += ser_vector(self.inputs)
        r += ser_uint256(self.txid)
        r += ser_uint256(self.cycleHash)
        r += self.sig
        return r

    def __repr__(self):
        return "msg_isdlock(nVersion=%d, inputs=%s, txid=%064x, cycleHash=%064x)" % \
               (self.nVersion, repr(self.inputs), self.txid, self.cycleHash)


class msg_qsigshare:
    __slots__ = ("sig_shares",)
    command = b"qsigshare"

    def __init__(self, sig_shares=[]):
        self.sig_shares = sig_shares

    def deserialize(self, f):
        self.sig_shares = deser_vector(f, CSigShare)

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

    def __repr__(self):
        return "msg_qsigshare(sigShares=%d)" % (len(self.sig_shares))


class msg_qwatch:
    __slots__ = ()
    command = b"qwatch"

    def __init__(self):
        pass

    def deserialize(self, f):
        pass

    def serialize(self):
        return b""

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


class msg_qgetdata:
    __slots__ = ("quorum_hash", "quorum_type", "data_mask", "protx_hash")
    command = b"qgetdata"

    def __init__(self, quorum_hash=0, quorum_type=-1, data_mask=0, protx_hash=0):
        self.quorum_hash = quorum_hash
        self.quorum_type = quorum_type
        self.data_mask = data_mask
        self.protx_hash = protx_hash

    def deserialize(self, f):
        self.quorum_type = struct.unpack("<B", f.read(1))[0]
        self.quorum_hash = deser_uint256(f)
        self.data_mask = struct.unpack("<H", f.read(2))[0]
        self.protx_hash = deser_uint256(f)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.quorum_type)
        r += ser_uint256(self.quorum_hash)
        r += struct.pack("<H", self.data_mask)
        r += ser_uint256(self.protx_hash)
        return r

    def __repr__(self):
        return "msg_qgetdata(quorum_hash=%064x, quorum_type=%d, data_mask=%d, protx_hash=%064x)" % (
                                                                                self.quorum_hash,
                                                                                self.quorum_type,
                                                                                self.data_mask,
                                                                                self.protx_hash)


class msg_qdata:
    __slots__ = ("quorum_hash", "quorum_type", "data_mask", "protx_hash", "error", "quorum_vvec", "enc_contributions",)
    command = b"qdata"

    def __init__(self):
        self.quorum_type = 0
        self.quorum_hash = 0
        self.data_mask = 0
        self.protx_hash = 0
        self.error = 0
        self.quorum_vvec = list()
        self.enc_contributions = list()

    def deserialize(self, f):
        self.quorum_type = struct.unpack("<B", f.read(1))[0]
        self.quorum_hash = deser_uint256(f)
        self.data_mask = struct.unpack("<H", f.read(2))[0]
        self.protx_hash = deser_uint256(f)
        self.error = struct.unpack("<B", f.read(1))[0]
        if self.error == 0:
            if self.data_mask & 0x01:
                self.quorum_vvec = deser_vector(f, CBLSPublicKey)
            if self.data_mask & 0x02:
                self.enc_contributions = deser_vector(f, CBLSIESEncryptedSecretKey)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.quorum_type)
        r += ser_uint256(self.quorum_hash)
        r += struct.pack("<H", self.data_mask)
        r += ser_uint256(self.protx_hash)
        r += struct.pack("<B", self.error)
        if self.error == 0:
            if self.data_mask & 0x01:
                r += ser_vector(self.quorum_vvec)
            if self.data_mask & 0x02:
                r += ser_vector(self.enc_contributions)
        return r

    def __repr__(self):
        return "msg_qdata(error=%d, quorum_vvec=%d, enc_contributions=%d)" % (self.error, len(self.quorum_vvec),
                                                                                          len(self.enc_contributions))

class msg_getcfilters:
    __slots__ = ("filter_type", "start_height", "stop_hash")
    command =  b"getcfilters"

    def __init__(self, filter_type, start_height, stop_hash):
        self.filter_type = filter_type
        self.start_height = start_height
        self.stop_hash = stop_hash

    def deserialize(self, f):
        self.filter_type = struct.unpack("<B", f.read(1))[0]
        self.start_height = struct.unpack("<I", f.read(4))[0]
        self.stop_hash = deser_uint256(f)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.filter_type)
        r += struct.pack("<I", self.start_height)
        r += ser_uint256(self.stop_hash)
        return r

    def __repr__(self):
        return "msg_getcfilters(filter_type={:#x}, start_height={}, stop_hash={:x})".format(
            self.filter_type, self.start_height, self.stop_hash)

class msg_cfilter:
    __slots__ = ("filter_type", "block_hash", "filter_data")
    command =  b"cfilter"

    def __init__(self, filter_type=None, block_hash=None, filter_data=None):
        self.filter_type = filter_type
        self.block_hash = block_hash
        self.filter_data = filter_data

    def deserialize(self, f):
        self.filter_type = struct.unpack("<B", f.read(1))[0]
        self.block_hash = deser_uint256(f)
        self.filter_data = deser_string(f)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.filter_type)
        r += ser_uint256(self.block_hash)
        r += ser_string(self.filter_data)
        return r

    def __repr__(self):
        return "msg_cfilter(filter_type={:#x}, block_hash={:x})".format(
            self.filter_type, self.block_hash)

class msg_getcfheaders:
    __slots__ = ("filter_type", "start_height", "stop_hash")
    command =  b"getcfheaders"

    def __init__(self, filter_type, start_height, stop_hash):
        self.filter_type = filter_type
        self.start_height = start_height
        self.stop_hash = stop_hash

    def deserialize(self, f):
        self.filter_type = struct.unpack("<B", f.read(1))[0]
        self.start_height = struct.unpack("<I", f.read(4))[0]
        self.stop_hash = deser_uint256(f)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.filter_type)
        r += struct.pack("<I", self.start_height)
        r += ser_uint256(self.stop_hash)
        return r

    def __repr__(self):
        return "msg_getcfheaders(filter_type={:#x}, start_height={}, stop_hash={:x})".format(
            self.filter_type, self.start_height, self.stop_hash)

class msg_cfheaders:
    __slots__ = ("filter_type", "stop_hash", "prev_header", "hashes")
    command =  b"cfheaders"

    def __init__(self, filter_type=None, stop_hash=None, prev_header=None, hashes=None):
        self.filter_type = filter_type
        self.stop_hash = stop_hash
        self.prev_header = prev_header
        self.hashes = hashes

    def deserialize(self, f):
        self.filter_type = struct.unpack("<B", f.read(1))[0]
        self.stop_hash = deser_uint256(f)
        self.prev_header = deser_uint256(f)
        self.hashes = deser_uint256_vector(f)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.filter_type)
        r += ser_uint256(self.stop_hash)
        r += ser_uint256(self.prev_header)
        r += ser_uint256_vector(self.hashes)
        return r

    def __repr__(self):
        return "msg_cfheaders(filter_type={:#x}, stop_hash={:x})".format(
            self.filter_type, self.stop_hash)

class msg_getcfcheckpt:
    __slots__ = ("filter_type", "stop_hash")
    command =  b"getcfcheckpt"

    def __init__(self, filter_type, stop_hash):
        self.filter_type = filter_type
        self.stop_hash = stop_hash

    def deserialize(self, f):
        self.filter_type = struct.unpack("<B", f.read(1))[0]
        self.stop_hash = deser_uint256(f)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.filter_type)
        r += ser_uint256(self.stop_hash)
        return r

    def __repr__(self):
        return "msg_getcfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
            self.filter_type, self.stop_hash)

class msg_cfcheckpt:
    __slots__ = ("filter_type", "stop_hash", "headers")
    command =  b"cfcheckpt"

    def __init__(self, filter_type=None, stop_hash=None, headers=None):
        self.filter_type = filter_type
        self.stop_hash = stop_hash
        self.headers = headers

    def deserialize(self, f):
        self.filter_type = struct.unpack("<B", f.read(1))[0]
        self.stop_hash = deser_uint256(f)
        self.headers = deser_uint256_vector(f)

    def serialize(self):
        r = b""
        r += struct.pack("<B", self.filter_type)
        r += ser_uint256(self.stop_hash)
        r += ser_uint256_vector(self.headers)
        return r

    def __repr__(self):
        return "msg_cfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
            self.filter_type, self.stop_hash)