Inside Bitcoin

1501
1502    def serialize(self):
1503        return ser_vector(self.vec)
1504
1505    def __repr__(self):
1506        return "msg_notfound(vec=%s)" % (repr(self.vec))
1507
1508
1509class msg_sendheaders:
1510    __slots__ = ()
1511    msgtype = b"sendheaders"
1512
1513    def __init__(self):
1514        pass
1515
1516    def deserialize(self, f):
1517        pass
1518
1519    def serialize(self):
1520        return b""
1521
1522    def __repr__(self):
1523        return "msg_sendheaders()"
1524
1525
1526# getheaders message has
1527# number of entries
1528# vector of hashes
1529# hash_stop (hash of last desired block header, 0 to get as many as possible)
1530class msg_getheaders:
1531    __slots__ = ("hashstop", "locator",)
1532    msgtype = b"getheaders"
1533
1534    def __init__(self):
1535        self.locator = CBlockLocator()
1536        self.hashstop = 0
1537
1538    def deserialize(self, f):
1539        self.locator = CBlockLocator()
1540        self.locator.deserialize(f)
1541        self.hashstop = deser_uint256(f)
1542
1543    def serialize(self):
1544        r = b""
1545        r += self.locator.serialize()
1546        r += ser_uint256(self.hashstop)
1547        return r
1548
1549    def __repr__(self):
1550        return "msg_getheaders(locator=%s, stop=%064x)" \
1551            % (repr(self.locator), self.hashstop)
1552
1553
1554# headers message has
1555# <count> <vector of block headers>
1556class msg_headers:
1557    __slots__ = ("headers",)
1558    msgtype = b"headers"
1559
1560    def __init__(self, headers=None):
1561        self.headers = headers if headers is not None else []
1562
1563    def deserialize(self, f):
1564        # comment in bitcoind indicates these should be deserialized as blocks
1565        blocks = deser_vector(f, CBlock)
1566        for x in blocks:
1567            self.headers.append(CBlockHeader(x))
1568
1569    def serialize(self):
1570        blocks = [CBlock(x) for x in self.headers]
1571        return ser_vector(blocks)
1572
1573    def __repr__(self):
1574        return "msg_headers(headers=%s)" % repr(self.headers)
1575
1576
1577class msg_merkleblock:
1578    __slots__ = ("merkleblock",)
1579    msgtype = b"merkleblock"
1580
1581    def __init__(self, merkleblock=None):
1582        if merkleblock is None:
1583            self.merkleblock = CMerkleBlock()
1584        else:
1585            self.merkleblock = merkleblock
1586
1587    def deserialize(self, f):
1588        self.merkleblock.deserialize(f)
1589
1590    def serialize(self):
1591        return self.merkleblock.serialize()
1592
1593    def __repr__(self):
1594        return "msg_merkleblock(merkleblock=%s)" % (repr(self.merkleblock))
1595
1596
1597class msg_filterload:
1598    __slots__ = ("data", "nHashFuncs", "nTweak", "nFlags")
1599    msgtype = b"filterload"
1600
1601    def __init__(self, data=b'00', nHashFuncs=0, nTweak=0, nFlags=0):
1602        self.data = data
1603        self.nHashFuncs = nHashFuncs
1604        self.nTweak = nTweak
1605        self.nFlags = nFlags
1606
1607    def deserialize(self, f):
1608        self.data = deser_string(f)
1609        self.nHashFuncs = int.from_bytes(f.read(4), "little")
1610        self.nTweak = int.from_bytes(f.read(4), "little")
1611        self.nFlags = int.from_bytes(f.read(1), "little")
1612
1613    def serialize(self):
1614        r = b""
1615        r += ser_string(self.data)
1616        r += self.nHashFuncs.to_bytes(4, "little")
1617        r += self.nTweak.to_bytes(4, "little")
1618        r += self.nFlags.to_bytes(1, "little")
1619        return r
1620
1621    def __repr__(self):
1622        return "msg_filterload(data={}, nHashFuncs={}, nTweak={}, nFlags={})".format(
1623            self.data, self.nHashFuncs, self.nTweak, self.nFlags)
1624
1625
1626class msg_filteradd:
1627    __slots__ = ("data")
1628    msgtype = b"filteradd"
1629
1630    def __init__(self, data):
1631        self.data = data
1632
1633    def deserialize(self, f):
1634        self.data = deser_string(f)
1635
1636    def serialize(self):
1637        r = b""
1638        r += ser_string(self.data)
1639        return r
1640
1641    def __repr__(self):
1642        return "msg_filteradd(data={})".format(self.data)
1643
1644
1645class msg_filterclear:
1646    __slots__ = ()
1647    msgtype = b"filterclear"
1648
1649    def __init__(self):
1650        pass
1651
1652    def deserialize(self, f):
1653        pass
1654
1655    def serialize(self):
1656        return b""
1657
1658    def __repr__(self):
1659        return "msg_filterclear()"
1660
1661
1662class msg_feefilter:
1663    __slots__ = ("feerate",)
1664    msgtype = b"feefilter"
1665
1666    def __init__(self, feerate=0):
1667        self.feerate = feerate
1668
1669    def deserialize(self, f):
1670        self.feerate = int.from_bytes(f.read(8), "little")
1671
1672    def serialize(self):
1673        r = b""
1674        r += self.feerate.to_bytes(8, "little")
1675        return r
1676
1677    def __repr__(self):
1678        return "msg_feefilter(feerate=%08x)" % self.feerate
1679
1680
1681class msg_sendcmpct:
1682    __slots__ = ("announce", "version")
1683    msgtype = b"sendcmpct"
1684
1685    def __init__(self, announce=False, version=2):
1686        self.announce = announce
1687        self.version = version
1688
1689    def deserialize(self, f):
1690        self.announce = bool(int.from_bytes(f.read(1), "little"))
1691        self.version = int.from_bytes(f.read(8), "little")
1692
1693    def serialize(self):
1694        r = b""
1695        r += int(self.announce).to_bytes(1, "little")
1696        r += self.version.to_bytes(8, "little")
1697        return r
1698
1699    def __repr__(self):
1700        return "msg_sendcmpct(announce=%s, version=%lu)" % (self.announce, self.version)
1701
1702
1703class msg_cmpctblock:
1704    __slots__ = ("header_and_shortids",)
1705    msgtype = b"cmpctblock"
1706
1707    def __init__(self, header_and_shortids = None):
1708        self.header_and_shortids = header_and_shortids
1709
1710    def deserialize(self, f):
1711        self.header_and_shortids = P2PHeaderAndShortIDs()
1712        self.header_and_shortids.deserialize(f)
1713
1714    def serialize(self):
1715        r = b""
1716        r += self.header_and_shortids.serialize()
1717        return r
1718
1719    def __repr__(self):
1720        return "msg_cmpctblock(HeaderAndShortIDs=%s)" % repr(self.header_and_shortids)
1721
1722
1723class msg_getblocktxn:
1724    __slots__ = ("block_txn_request",)
1725    msgtype = b"getblocktxn"
1726
1727    def __init__(self):
1728        self.block_txn_request = None
1729
1730    def deserialize(self, f):
1731        self.block_txn_request = BlockTransactionsRequest()
1732        self.block_txn_request.deserialize(f)
1733
1734    def serialize(self):
1735        r = b""
1736        r += self.block_txn_request.serialize()
1737        return r
1738
1739    def __repr__(self):
1740        return "msg_getblocktxn(block_txn_request=%s)" % (repr(self.block_txn_request))
1741
1742
1743class msg_blocktxn:
1744    __slots__ = ("block_transactions",)
1745    msgtype = b"blocktxn"
1746
1747    def __init__(self):
1748        self.block_transactions = BlockTransactions()
1749
1750    def deserialize(self, f):