Inside Bitcoin

1751        self.block_transactions.deserialize(f)
1752
1753    def serialize(self):
1754        r = b""
1755        r += self.block_transactions.serialize()
1756        return r
1757
1758    def __repr__(self):
1759        return "msg_blocktxn(block_transactions=%s)" % (repr(self.block_transactions))
1760
1761
1762class msg_no_witness_blocktxn(msg_blocktxn):
1763    __slots__ = ()
1764
1765    def serialize(self):
1766        return self.block_transactions.serialize(with_witness=False)
1767
1768
1769class msg_getcfilters:
1770    __slots__ = ("filter_type", "start_height", "stop_hash")
1771    msgtype =  b"getcfilters"
1772
1773    def __init__(self, filter_type=None, start_height=None, stop_hash=None):
1774        self.filter_type = filter_type
1775        self.start_height = start_height
1776        self.stop_hash = stop_hash
1777
1778    def deserialize(self, f):
1779        self.filter_type = int.from_bytes(f.read(1), "little")
1780        self.start_height = int.from_bytes(f.read(4), "little")
1781        self.stop_hash = deser_uint256(f)
1782
1783    def serialize(self):
1784        r = b""
1785        r += self.filter_type.to_bytes(1, "little")
1786        r += self.start_height.to_bytes(4, "little")
1787        r += ser_uint256(self.stop_hash)
1788        return r
1789
1790    def __repr__(self):
1791        return "msg_getcfilters(filter_type={:#x}, start_height={}, stop_hash={:x})".format(
1792            self.filter_type, self.start_height, self.stop_hash)
1793
1794class msg_cfilter:
1795    __slots__ = ("filter_type", "block_hash", "filter_data")
1796    msgtype =  b"cfilter"
1797
1798    def __init__(self, filter_type=None, block_hash=None, filter_data=None):
1799        self.filter_type = filter_type
1800        self.block_hash = block_hash
1801        self.filter_data = filter_data
1802
1803    def deserialize(self, f):
1804        self.filter_type = int.from_bytes(f.read(1), "little")
1805        self.block_hash = deser_uint256(f)
1806        self.filter_data = deser_string(f)
1807
1808    def serialize(self):
1809        r = b""
1810        r += self.filter_type.to_bytes(1, "little")
1811        r += ser_uint256(self.block_hash)
1812        r += ser_string(self.filter_data)
1813        return r
1814
1815    def __repr__(self):
1816        return "msg_cfilter(filter_type={:#x}, block_hash={:x})".format(
1817            self.filter_type, self.block_hash)
1818
1819class msg_getcfheaders:
1820    __slots__ = ("filter_type", "start_height", "stop_hash")
1821    msgtype =  b"getcfheaders"
1822
1823    def __init__(self, filter_type=None, start_height=None, stop_hash=None):
1824        self.filter_type = filter_type
1825        self.start_height = start_height
1826        self.stop_hash = stop_hash
1827
1828    def deserialize(self, f):
1829        self.filter_type = int.from_bytes(f.read(1), "little")
1830        self.start_height = int.from_bytes(f.read(4), "little")
1831        self.stop_hash = deser_uint256(f)
1832
1833    def serialize(self):
1834        r = b""
1835        r += self.filter_type.to_bytes(1, "little")
1836        r += self.start_height.to_bytes(4, "little")
1837        r += ser_uint256(self.stop_hash)
1838        return r
1839
1840    def __repr__(self):
1841        return "msg_getcfheaders(filter_type={:#x}, start_height={}, stop_hash={:x})".format(
1842            self.filter_type, self.start_height, self.stop_hash)
1843
1844class msg_cfheaders:
1845    __slots__ = ("filter_type", "stop_hash", "prev_header", "hashes")
1846    msgtype =  b"cfheaders"
1847
1848    def __init__(self, filter_type=None, stop_hash=None, prev_header=None, hashes=None):
1849        self.filter_type = filter_type
1850        self.stop_hash = stop_hash
1851        self.prev_header = prev_header
1852        self.hashes = hashes
1853
1854    def deserialize(self, f):
1855        self.filter_type = int.from_bytes(f.read(1), "little")
1856        self.stop_hash = deser_uint256(f)
1857        self.prev_header = deser_uint256(f)
1858        self.hashes = deser_uint256_vector(f)
1859
1860    def serialize(self):
1861        r = b""
1862        r += self.filter_type.to_bytes(1, "little")
1863        r += ser_uint256(self.stop_hash)
1864        r += ser_uint256(self.prev_header)
1865        r += ser_uint256_vector(self.hashes)
1866        return r
1867
1868    def __repr__(self):
1869        return "msg_cfheaders(filter_type={:#x}, stop_hash={:x})".format(
1870            self.filter_type, self.stop_hash)
1871
1872class msg_getcfcheckpt:
1873    __slots__ = ("filter_type", "stop_hash")
1874    msgtype =  b"getcfcheckpt"
1875
1876    def __init__(self, filter_type=None, stop_hash=None):
1877        self.filter_type = filter_type
1878        self.stop_hash = stop_hash
1879
1880    def deserialize(self, f):
1881        self.filter_type = int.from_bytes(f.read(1), "little")
1882        self.stop_hash = deser_uint256(f)
1883
1884    def serialize(self):
1885        r = b""
1886        r += self.filter_type.to_bytes(1, "little")
1887        r += ser_uint256(self.stop_hash)
1888        return r
1889
1890    def __repr__(self):
1891        return "msg_getcfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
1892            self.filter_type, self.stop_hash)
1893
1894class msg_cfcheckpt:
1895    __slots__ = ("filter_type", "stop_hash", "headers")
1896    msgtype =  b"cfcheckpt"
1897
1898    def __init__(self, filter_type=None, stop_hash=None, headers=None):
1899        self.filter_type = filter_type
1900        self.stop_hash = stop_hash
1901        self.headers = headers
1902
1903    def deserialize(self, f):
1904        self.filter_type = int.from_bytes(f.read(1), "little")
1905        self.stop_hash = deser_uint256(f)
1906        self.headers = deser_uint256_vector(f)
1907
1908    def serialize(self):
1909        r = b""
1910        r += self.filter_type.to_bytes(1, "little")
1911        r += ser_uint256(self.stop_hash)
1912        r += ser_uint256_vector(self.headers)
1913        return r
1914
1915    def __repr__(self):
1916        return "msg_cfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
1917            self.filter_type, self.stop_hash)
1918
1919class msg_sendtxrcncl:
1920    __slots__ = ("version", "salt")
1921    msgtype = b"sendtxrcncl"
1922
1923    def __init__(self):
1924        self.version = 0
1925        self.salt = 0
1926
1927    def deserialize(self, f):
1928        self.version = int.from_bytes(f.read(4), "little")
1929        self.salt = int.from_bytes(f.read(8), "little")
1930
1931    def serialize(self):
1932        r = b""
1933        r += self.version.to_bytes(4, "little")
1934        r += self.salt.to_bytes(8, "little")
1935        return r
1936
1937    def __repr__(self):
1938        return "msg_sendtxrcncl(version=%lu, salt=%lu)" %\
1939            (self.version, self.salt)
1940
1941class msg_feature:
1942    """FEATURE message for negotiating optional features."""
1943    __slots__ = ("feature_id", "feature_data")
1944    msgtype = b"feature"
1945
1946    def __init__(self, feature_id="", feature_data=b""):
1947        self.feature_id = feature_id
1948        self.feature_data = feature_data
1949
1950    def deserialize(self, f):
1951        self.feature_id = deser_string(f).decode()
1952        self.feature_data = deser_string(f)
1953
1954    def serialize(self):
1955        r = ser_string(self.feature_id.encode())
1956        r += ser_string(self.feature_data)
1957        return r
1958
1959    def __repr__(self):
1960        return f"msg_feature(feature_id={self.feature_id}, data={self.feature_data.hex()})"
1961
1962
1963class TestFrameworkScript(unittest.TestCase):
1964    def test_addrv2_encode_decode(self):
1965        def check_addrv2(ip, net):
1966            addr = CAddress()
1967            addr.net, addr.ip = net, ip
1968            ser = addr.serialize_v2()
1969            actual = CAddress()
1970            actual.deserialize_v2(BytesIO(ser))
1971            self.assertEqual(actual, addr)
1972
1973        check_addrv2("1.65.195.98", CAddress.NET_IPV4)
1974        check_addrv2("2001:41f0::62:6974:636f:696e", CAddress.NET_IPV6)
1975        check_addrv2("2bqghnldu6mcug4pikzprwhtjjnsyederctvci6klcwzepnjd46ikjyd.onion", CAddress.NET_TORV3)
1976        check_addrv2("255fhcp6ajvftnyo7bwz3an3t4a4brhopm3bamyh2iu5r3gnr2rq.b32.i2p", CAddress.NET_I2P)
1977        check_addrv2("fc32:17ea:e415:c3bf:9808:149d:b5a2:c9aa", CAddress.NET_CJDNS)
1978
1979    def test_varint_encode_decode(self):
1980        def check_varint(num, expected_encoding_hex):
1981            expected_encoding = bytes.fromhex(expected_encoding_hex)
1982            self.assertEqual(ser_varint(num), expected_encoding)
1983            self.assertEqual(deser_varint(BytesIO(expected_encoding)), num)
1984
1985        # test cases from serialize_tests.cpp:varint_bitpatterns
1986        check_varint(0, "00")
1987        check_varint(0x7f, "7f")
1988        check_varint(0x80, "8000")
1989        check_varint(0x1234, "a334")
1990        check_varint(0xffff, "82fe7f")
1991        check_varint(0x123456, "c7e756")
1992        check_varint(0x80123456, "86ffc7e756")
1993        check_varint(0xffffffff, "8efefefe7f")
1994        check_varint(0xffffffffffffffff, "80fefefefefefefefe7f")
1995