Inside Bitcoin

1251        return ser_vector(self.addrs, "serialize_v2")
1252
1253    def __repr__(self):
1254        return "msg_addrv2(addrs=%s)" % (repr(self.addrs))
1255
1256
1257class msg_sendaddrv2:
1258    __slots__ = ()
1259    msgtype = b"sendaddrv2"
1260
1261    def __init__(self):
1262        pass
1263
1264    def deserialize(self, f):
1265        pass
1266
1267    def serialize(self):
1268        return b""
1269
1270    def __repr__(self):
1271        return "msg_sendaddrv2()"
1272
1273
1274class msg_inv:
1275    __slots__ = ("inv",)
1276    msgtype = b"inv"
1277
1278    def __init__(self, inv=None):
1279        if inv is None:
1280            self.inv = []
1281        else:
1282            self.inv = inv
1283
1284    def deserialize(self, f):
1285        self.inv = deser_vector(f, CInv)
1286
1287    def serialize(self):
1288        return ser_vector(self.inv)
1289
1290    def __repr__(self):
1291        return "msg_inv(inv=%s)" % (repr(self.inv))
1292
1293
1294class msg_getdata:
1295    __slots__ = ("inv",)
1296    msgtype = b"getdata"
1297
1298    def __init__(self, inv=None):
1299        self.inv = inv if inv is not None else []
1300
1301    def deserialize(self, f):
1302        self.inv = deser_vector(f, CInv)
1303
1304    def serialize(self):
1305        return ser_vector(self.inv)
1306
1307    def __repr__(self):
1308        return "msg_getdata(inv=%s)" % (repr(self.inv))
1309
1310
1311class msg_getblocks:
1312    __slots__ = ("locator", "hashstop")
1313    msgtype = b"getblocks"
1314
1315    def __init__(self):
1316        self.locator = CBlockLocator()
1317        self.hashstop = 0
1318
1319    def deserialize(self, f):
1320        self.locator = CBlockLocator()
1321        self.locator.deserialize(f)
1322        self.hashstop = deser_uint256(f)
1323
1324    def serialize(self):
1325        r = b""
1326        r += self.locator.serialize()
1327        r += ser_uint256(self.hashstop)
1328        return r
1329
1330    def __repr__(self):
1331        return "msg_getblocks(locator=%s hashstop=%064x)" \
1332            % (repr(self.locator), self.hashstop)
1333
1334
1335class msg_tx:
1336    __slots__ = ("tx",)
1337    msgtype = b"tx"
1338
1339    def __init__(self, tx=None):
1340        if tx is None:
1341            self.tx = CTransaction()
1342        else:
1343            self.tx = tx
1344
1345    def deserialize(self, f):
1346        self.tx.deserialize(f)
1347
1348    def serialize(self):
1349        return self.tx.serialize_with_witness()
1350
1351    def __repr__(self):
1352        return "msg_tx(tx=%s)" % (repr(self.tx))
1353
1354class msg_wtxidrelay:
1355    __slots__ = ()
1356    msgtype = b"wtxidrelay"
1357
1358    def __init__(self):
1359        pass
1360
1361    def deserialize(self, f):
1362        pass
1363
1364    def serialize(self):
1365        return b""
1366
1367    def __repr__(self):
1368        return "msg_wtxidrelay()"
1369
1370
1371class msg_no_witness_tx(msg_tx):
1372    __slots__ = ()
1373
1374    def serialize(self):
1375        return self.tx.serialize_without_witness()
1376
1377
1378class msg_block:
1379    __slots__ = ("block",)
1380    msgtype = b"block"
1381
1382    def __init__(self, block=None):
1383        if block is None:
1384            self.block = CBlock()
1385        else:
1386            self.block = block
1387
1388    def deserialize(self, f):
1389        self.block.deserialize(f)
1390
1391    def serialize(self):
1392        return self.block.serialize()
1393
1394    def __repr__(self):
1395        return "msg_block(block=%s)" % (repr(self.block))
1396
1397
1398# Generic type to control the raw bytes sent over the wire.
1399# The msgtype and the data must be provided.
1400class msg_generic:
1401    __slots__ = ("msgtype", "data")
1402
1403    def __init__(self, msgtype, data=None):
1404        self.msgtype = msgtype
1405        self.data = data
1406
1407    def serialize(self):
1408        return self.data
1409
1410    def __repr__(self):
1411        return "msg_generic()"
1412
1413
1414class msg_no_witness_block(msg_block):
1415    __slots__ = ()
1416    def serialize(self):
1417        return self.block.serialize(with_witness=False)
1418
1419
1420class msg_getaddr:
1421    __slots__ = ()
1422    msgtype = b"getaddr"
1423
1424    def __init__(self):
1425        pass
1426
1427    def deserialize(self, f):
1428        pass
1429
1430    def serialize(self):
1431        return b""
1432
1433    def __repr__(self):
1434        return "msg_getaddr()"
1435
1436
1437class msg_ping:
1438    __slots__ = ("nonce",)
1439    msgtype = b"ping"
1440
1441    def __init__(self, nonce=0):
1442        self.nonce = nonce
1443
1444    def deserialize(self, f):
1445        self.nonce = int.from_bytes(f.read(8), "little")
1446
1447    def serialize(self):
1448        r = b""
1449        r += self.nonce.to_bytes(8, "little")
1450        return r
1451
1452    def __repr__(self):
1453        return "msg_ping(nonce=%08x)" % self.nonce
1454
1455
1456class msg_pong:
1457    __slots__ = ("nonce",)
1458    msgtype = b"pong"
1459
1460    def __init__(self, nonce=0):
1461        self.nonce = nonce
1462
1463    def deserialize(self, f):
1464        self.nonce = int.from_bytes(f.read(8), "little")
1465
1466    def serialize(self):
1467        r = b""
1468        r += self.nonce.to_bytes(8, "little")
1469        return r
1470
1471    def __repr__(self):
1472        return "msg_pong(nonce=%08x)" % self.nonce
1473
1474
1475class msg_mempool:
1476    __slots__ = ()
1477    msgtype = b"mempool"
1478
1479    def __init__(self):
1480        pass
1481
1482    def deserialize(self, f):
1483        pass
1484
1485    def serialize(self):
1486        return b""
1487
1488    def __repr__(self):
1489        return "msg_mempool()"
1490
1491
1492class msg_notfound:
1493    __slots__ = ("vec", )
1494    msgtype = b"notfound"
1495
1496    def __init__(self, vec=None):
1497        self.vec = vec or []
1498
1499    def deserialize(self, f):
1500        self.vec = deser_vector(f, CInv)