Changeset View
Changeset View
Standalone View
Standalone View
test/functional/test_framework/messages.py
| Show First 20 Lines • Show All 913 Lines • ▼ Show 20 Lines | def __repr__(self): | ||||
| repr(self.header), repr(self.txn)) | repr(self.header), repr(self.txn)) | ||||
| # Objects that correspond to messages on the wire | # Objects that correspond to messages on the wire | ||||
| class msg_version: | class msg_version: | ||||
| __slots__ = ("addrFrom", "addrTo", "nNonce", "nRelay", "nServices", | __slots__ = ("addrFrom", "addrTo", "nNonce", "nRelay", "nServices", | ||||
| "nStartingHeight", "nTime", "nVersion", "strSubVer") | "nStartingHeight", "nTime", "nVersion", "strSubVer") | ||||
| command = b"version" | msgtype = b"version" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.nVersion = MY_VERSION | self.nVersion = MY_VERSION | ||||
| self.nServices = 1 | self.nServices = 1 | ||||
| self.nTime = int(time.time()) | self.nTime = int(time.time()) | ||||
| self.addrTo = CAddress() | self.addrTo = CAddress() | ||||
| self.addrFrom = CAddress() | self.addrFrom = CAddress() | ||||
| self.nNonce = random.getrandbits(64) | self.nNonce = random.getrandbits(64) | ||||
| ▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines | def __repr__(self): | ||||
| return 'msg_version(nVersion={} nServices={} nTime={} addrTo={} addrFrom={} nNonce=0x{:016X} strSubVer={} nStartingHeight={} nRelay={})'.format( | return 'msg_version(nVersion={} nServices={} nTime={} addrTo={} addrFrom={} nNonce=0x{:016X} strSubVer={} nStartingHeight={} nRelay={})'.format( | ||||
| self.nVersion, self.nServices, self.nTime, | self.nVersion, self.nServices, self.nTime, | ||||
| repr(self.addrTo), repr(self.addrFrom), self.nNonce, | repr(self.addrTo), repr(self.addrFrom), self.nNonce, | ||||
| self.strSubVer, self.nStartingHeight, self.nRelay) | self.strSubVer, self.nStartingHeight, self.nRelay) | ||||
| class msg_verack: | class msg_verack: | ||||
| __slots__ = () | __slots__ = () | ||||
| command = b"verack" | msgtype = b"verack" | ||||
| def __init__(self): | def __init__(self): | ||||
| pass | pass | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| pass | pass | ||||
| def serialize(self): | def serialize(self): | ||||
| return b"" | return b"" | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_verack()" | return "msg_verack()" | ||||
| class msg_addr: | class msg_addr: | ||||
| __slots__ = ("addrs",) | __slots__ = ("addrs",) | ||||
| command = b"addr" | msgtype = b"addr" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.addrs = [] | self.addrs = [] | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.addrs = deser_vector(f, CAddress) | self.addrs = deser_vector(f, CAddress) | ||||
| def serialize(self): | def serialize(self): | ||||
| return ser_vector(self.addrs) | return ser_vector(self.addrs) | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_addr(addrs={})".format(repr(self.addrs)) | return "msg_addr(addrs={})".format(repr(self.addrs)) | ||||
| class msg_inv: | class msg_inv: | ||||
| __slots__ = ("inv",) | __slots__ = ("inv",) | ||||
| command = b"inv" | msgtype = b"inv" | ||||
| def __init__(self, inv=None): | def __init__(self, inv=None): | ||||
| if inv is None: | if inv is None: | ||||
| self.inv = [] | self.inv = [] | ||||
| else: | else: | ||||
| self.inv = inv | self.inv = inv | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.inv = deser_vector(f, CInv) | self.inv = deser_vector(f, CInv) | ||||
| def serialize(self): | def serialize(self): | ||||
| return ser_vector(self.inv) | return ser_vector(self.inv) | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_inv(inv={})".format(repr(self.inv)) | return "msg_inv(inv={})".format(repr(self.inv)) | ||||
| class msg_getdata: | class msg_getdata: | ||||
| __slots__ = ("inv",) | __slots__ = ("inv",) | ||||
| command = b"getdata" | msgtype = b"getdata" | ||||
| def __init__(self, inv=None): | def __init__(self, inv=None): | ||||
| self.inv = inv if inv is not None else [] | self.inv = inv if inv is not None else [] | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.inv = deser_vector(f, CInv) | self.inv = deser_vector(f, CInv) | ||||
| def serialize(self): | def serialize(self): | ||||
| return ser_vector(self.inv) | return ser_vector(self.inv) | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_getdata(inv={})".format(repr(self.inv)) | return "msg_getdata(inv={})".format(repr(self.inv)) | ||||
| class msg_getblocks: | class msg_getblocks: | ||||
| __slots__ = ("locator", "hashstop") | __slots__ = ("locator", "hashstop") | ||||
| command = b"getblocks" | msgtype = b"getblocks" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.locator = CBlockLocator() | self.locator = CBlockLocator() | ||||
| self.hashstop = 0 | self.hashstop = 0 | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.locator = CBlockLocator() | self.locator = CBlockLocator() | ||||
| self.locator.deserialize(f) | self.locator.deserialize(f) | ||||
| self.hashstop = deser_uint256(f) | self.hashstop = deser_uint256(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += self.locator.serialize() | r += self.locator.serialize() | ||||
| r += ser_uint256(self.hashstop) | r += ser_uint256(self.hashstop) | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_getblocks(locator={} hashstop={:064x})".format( | return "msg_getblocks(locator={} hashstop={:064x})".format( | ||||
| repr(self.locator), self.hashstop) | repr(self.locator), self.hashstop) | ||||
| class msg_tx: | class msg_tx: | ||||
| __slots__ = ("tx",) | __slots__ = ("tx",) | ||||
| command = b"tx" | msgtype = b"tx" | ||||
| def __init__(self, tx=CTransaction()): | def __init__(self, tx=CTransaction()): | ||||
| self.tx = tx | self.tx = tx | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.tx.deserialize(f) | self.tx.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| return self.tx.serialize() | return self.tx.serialize() | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_tx(tx={})".format(repr(self.tx)) | return "msg_tx(tx={})".format(repr(self.tx)) | ||||
| class msg_block: | class msg_block: | ||||
| __slots__ = ("block",) | __slots__ = ("block",) | ||||
| command = b"block" | msgtype = b"block" | ||||
| def __init__(self, block=None): | def __init__(self, block=None): | ||||
| if block is None: | if block is None: | ||||
| self.block = CBlock() | self.block = CBlock() | ||||
| else: | else: | ||||
| self.block = block | self.block = block | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.block.deserialize(f) | self.block.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| return self.block.serialize() | return self.block.serialize() | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_block(block={})".format(repr(self.block)) | return "msg_block(block={})".format(repr(self.block)) | ||||
| # for cases where a user needs tighter control over what is sent over the wire | # 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 | # note that the user must supply the name of the msgtype, and the data | ||||
| class msg_generic: | class msg_generic: | ||||
| __slots__ = ("command", "data") | __slots__ = ("msgtype", "data") | ||||
| def __init__(self, command, data=None): | def __init__(self, msgtype, data=None): | ||||
| self.command = command | self.msgtype = msgtype | ||||
| self.data = data | self.data = data | ||||
| def serialize(self): | def serialize(self): | ||||
| return self.data | return self.data | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_generic()" | return "msg_generic()" | ||||
| class msg_getaddr: | class msg_getaddr: | ||||
| __slots__ = () | __slots__ = () | ||||
| command = b"getaddr" | msgtype = b"getaddr" | ||||
| def __init__(self): | def __init__(self): | ||||
| pass | pass | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| pass | pass | ||||
| def serialize(self): | def serialize(self): | ||||
| return b"" | return b"" | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_getaddr()" | return "msg_getaddr()" | ||||
| class msg_ping: | class msg_ping: | ||||
| __slots__ = ("nonce",) | __slots__ = ("nonce",) | ||||
| command = b"ping" | msgtype = b"ping" | ||||
| def __init__(self, nonce=0): | def __init__(self, nonce=0): | ||||
| self.nonce = nonce | self.nonce = nonce | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.nonce = struct.unpack("<Q", f.read(8))[0] | self.nonce = struct.unpack("<Q", f.read(8))[0] | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += struct.pack("<Q", self.nonce) | r += struct.pack("<Q", self.nonce) | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_ping(nonce={:08x})".format(self.nonce) | return "msg_ping(nonce={:08x})".format(self.nonce) | ||||
| class msg_pong: | class msg_pong: | ||||
| __slots__ = ("nonce",) | __slots__ = ("nonce",) | ||||
| command = b"pong" | msgtype = b"pong" | ||||
| def __init__(self, nonce=0): | def __init__(self, nonce=0): | ||||
| self.nonce = nonce | self.nonce = nonce | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.nonce = struct.unpack("<Q", f.read(8))[0] | self.nonce = struct.unpack("<Q", f.read(8))[0] | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += struct.pack("<Q", self.nonce) | r += struct.pack("<Q", self.nonce) | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_pong(nonce={:08x})".format(self.nonce) | return "msg_pong(nonce={:08x})".format(self.nonce) | ||||
| class msg_mempool: | class msg_mempool: | ||||
| __slots__ = () | __slots__ = () | ||||
| command = b"mempool" | msgtype = b"mempool" | ||||
| def __init__(self): | def __init__(self): | ||||
| pass | pass | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| pass | pass | ||||
| def serialize(self): | def serialize(self): | ||||
| return b"" | return b"" | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_mempool()" | return "msg_mempool()" | ||||
| class msg_notfound: | class msg_notfound: | ||||
| __slots__ = ("vec", ) | __slots__ = ("vec", ) | ||||
| command = b"notfound" | msgtype = b"notfound" | ||||
| def __init__(self, vec=None): | def __init__(self, vec=None): | ||||
| self.vec = vec or [] | self.vec = vec or [] | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.vec = deser_vector(f, CInv) | self.vec = deser_vector(f, CInv) | ||||
| def serialize(self): | def serialize(self): | ||||
| return ser_vector(self.vec) | return ser_vector(self.vec) | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_notfound(vec={})".format(repr(self.vec)) | return "msg_notfound(vec={})".format(repr(self.vec)) | ||||
| class msg_sendheaders: | class msg_sendheaders: | ||||
| __slots__ = () | __slots__ = () | ||||
| command = b"sendheaders" | msgtype = b"sendheaders" | ||||
| def __init__(self): | def __init__(self): | ||||
| pass | pass | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| pass | pass | ||||
| def serialize(self): | def serialize(self): | ||||
| return b"" | return b"" | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_sendheaders()" | return "msg_sendheaders()" | ||||
| # getheaders message has | # getheaders message has | ||||
| # number of entries | # number of entries | ||||
| # vector of hashes | # vector of hashes | ||||
| # hash_stop (hash of last desired block header, 0 to get as many as possible) | # hash_stop (hash of last desired block header, 0 to get as many as possible) | ||||
| class msg_getheaders: | class msg_getheaders: | ||||
| __slots__ = ("hashstop", "locator",) | __slots__ = ("hashstop", "locator",) | ||||
| command = b"getheaders" | msgtype = b"getheaders" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.locator = CBlockLocator() | self.locator = CBlockLocator() | ||||
| self.hashstop = 0 | self.hashstop = 0 | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.locator = CBlockLocator() | self.locator = CBlockLocator() | ||||
| self.locator.deserialize(f) | self.locator.deserialize(f) | ||||
| Show All 9 Lines | def __repr__(self): | ||||
| return "msg_getheaders(locator={}, stop={:064x})".format( | return "msg_getheaders(locator={}, stop={:064x})".format( | ||||
| repr(self.locator), self.hashstop) | repr(self.locator), self.hashstop) | ||||
| # headers message has | # headers message has | ||||
| # <count> <vector of block headers> | # <count> <vector of block headers> | ||||
| class msg_headers: | class msg_headers: | ||||
| __slots__ = ("headers",) | __slots__ = ("headers",) | ||||
| command = b"headers" | msgtype = b"headers" | ||||
| def __init__(self, headers=None): | def __init__(self, headers=None): | ||||
| self.headers = headers if headers is not None else [] | self.headers = headers if headers is not None else [] | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| # comment in bitcoind indicates these should be deserialized as blocks | # comment in bitcoind indicates these should be deserialized as blocks | ||||
| blocks = deser_vector(f, CBlock) | blocks = deser_vector(f, CBlock) | ||||
| for x in blocks: | for x in blocks: | ||||
| self.headers.append(CBlockHeader(x)) | self.headers.append(CBlockHeader(x)) | ||||
| def serialize(self): | def serialize(self): | ||||
| blocks = [CBlock(x) for x in self.headers] | blocks = [CBlock(x) for x in self.headers] | ||||
| return ser_vector(blocks) | return ser_vector(blocks) | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_headers(headers={})".format(repr(self.headers)) | return "msg_headers(headers={})".format(repr(self.headers)) | ||||
| class msg_merkleblock: | class msg_merkleblock: | ||||
| __slots__ = ("merkleblock",) | __slots__ = ("merkleblock",) | ||||
| command = b"merkleblock" | msgtype = b"merkleblock" | ||||
| def __init__(self, merkleblock=None): | def __init__(self, merkleblock=None): | ||||
| if merkleblock is None: | if merkleblock is None: | ||||
| self.merkleblock = CMerkleBlock() | self.merkleblock = CMerkleBlock() | ||||
| else: | else: | ||||
| self.merkleblock = merkleblock | self.merkleblock = merkleblock | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.merkleblock.deserialize(f) | self.merkleblock.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| return self.merkleblock.serialize() | return self.merkleblock.serialize() | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_merkleblock(merkleblock={})".format(repr(self.merkleblock)) | return "msg_merkleblock(merkleblock={})".format(repr(self.merkleblock)) | ||||
| class msg_filterload: | class msg_filterload: | ||||
| __slots__ = ("data", "nHashFuncs", "nTweak", "nFlags") | __slots__ = ("data", "nHashFuncs", "nTweak", "nFlags") | ||||
| command = b"filterload" | msgtype = b"filterload" | ||||
| def __init__(self, data=b'00', nHashFuncs=0, nTweak=0, nFlags=0): | def __init__(self, data=b'00', nHashFuncs=0, nTweak=0, nFlags=0): | ||||
| self.data = data | self.data = data | ||||
| self.nHashFuncs = nHashFuncs | self.nHashFuncs = nHashFuncs | ||||
| self.nTweak = nTweak | self.nTweak = nTweak | ||||
| self.nFlags = nFlags | self.nFlags = nFlags | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| Show All 12 Lines | class msg_filterload: | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_filterload(data={}, nHashFuncs={}, nTweak={}, nFlags={})".format( | return "msg_filterload(data={}, nHashFuncs={}, nTweak={}, nFlags={})".format( | ||||
| self.data, self.nHashFuncs, self.nTweak, self.nFlags) | self.data, self.nHashFuncs, self.nTweak, self.nFlags) | ||||
| class msg_filteradd: | class msg_filteradd: | ||||
| __slots__ = ("data") | __slots__ = ("data") | ||||
| command = b"filteradd" | msgtype = b"filteradd" | ||||
| def __init__(self, data): | def __init__(self, data): | ||||
| self.data = data | self.data = data | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.data = deser_string(f) | self.data = deser_string(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += ser_string(self.data) | r += ser_string(self.data) | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_filteradd(data={})".format(self.data) | return "msg_filteradd(data={})".format(self.data) | ||||
| class msg_filterclear: | class msg_filterclear: | ||||
| __slots__ = () | __slots__ = () | ||||
| command = b"filterclear" | msgtype = b"filterclear" | ||||
| def __init__(self): | def __init__(self): | ||||
| pass | pass | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| pass | pass | ||||
| def serialize(self): | def serialize(self): | ||||
| return b"" | return b"" | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_filterclear()" | return "msg_filterclear()" | ||||
| class msg_feefilter: | class msg_feefilter: | ||||
| __slots__ = ("feerate",) | __slots__ = ("feerate",) | ||||
| command = b"feefilter" | msgtype = b"feefilter" | ||||
| def __init__(self, feerate=0): | def __init__(self, feerate=0): | ||||
| self.feerate = feerate | self.feerate = feerate | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.feerate = struct.unpack("<Q", f.read(8))[0] | self.feerate = struct.unpack("<Q", f.read(8))[0] | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += struct.pack("<Q", self.feerate) | r += struct.pack("<Q", self.feerate) | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_feefilter(feerate={:08x})".format(self.feerate) | return "msg_feefilter(feerate={:08x})".format(self.feerate) | ||||
| class msg_sendcmpct: | class msg_sendcmpct: | ||||
| __slots__ = ("announce", "version") | __slots__ = ("announce", "version") | ||||
| command = b"sendcmpct" | msgtype = b"sendcmpct" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.announce = False | self.announce = False | ||||
| self.version = 1 | self.version = 1 | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.announce = struct.unpack("<?", f.read(1))[0] | self.announce = struct.unpack("<?", f.read(1))[0] | ||||
| self.version = struct.unpack("<Q", f.read(8))[0] | self.version = struct.unpack("<Q", f.read(8))[0] | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += struct.pack("<?", self.announce) | r += struct.pack("<?", self.announce) | ||||
| r += struct.pack("<Q", self.version) | r += struct.pack("<Q", self.version) | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_sendcmpct(announce={}, version={})".format( | return "msg_sendcmpct(announce={}, version={})".format( | ||||
| self.announce, self.version) | self.announce, self.version) | ||||
| class msg_cmpctblock: | class msg_cmpctblock: | ||||
| __slots__ = ("header_and_shortids",) | __slots__ = ("header_and_shortids",) | ||||
| command = b"cmpctblock" | msgtype = b"cmpctblock" | ||||
| def __init__(self, header_and_shortids=None): | def __init__(self, header_and_shortids=None): | ||||
| self.header_and_shortids = header_and_shortids | self.header_and_shortids = header_and_shortids | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.header_and_shortids = P2PHeaderAndShortIDs() | self.header_and_shortids = P2PHeaderAndShortIDs() | ||||
| self.header_and_shortids.deserialize(f) | self.header_and_shortids.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += self.header_and_shortids.serialize() | r += self.header_and_shortids.serialize() | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_cmpctblock(HeaderAndShortIDs={})".format( | return "msg_cmpctblock(HeaderAndShortIDs={})".format( | ||||
| repr(self.header_and_shortids)) | repr(self.header_and_shortids)) | ||||
| class msg_getblocktxn: | class msg_getblocktxn: | ||||
| __slots__ = ("block_txn_request",) | __slots__ = ("block_txn_request",) | ||||
| command = b"getblocktxn" | msgtype = b"getblocktxn" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.block_txn_request = None | self.block_txn_request = None | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.block_txn_request = BlockTransactionsRequest() | self.block_txn_request = BlockTransactionsRequest() | ||||
| self.block_txn_request.deserialize(f) | self.block_txn_request.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += self.block_txn_request.serialize() | r += self.block_txn_request.serialize() | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_getblocktxn(block_txn_request={})".format( | return "msg_getblocktxn(block_txn_request={})".format( | ||||
| repr(self.block_txn_request)) | repr(self.block_txn_request)) | ||||
| class msg_blocktxn: | class msg_blocktxn: | ||||
| __slots__ = ("block_transactions",) | __slots__ = ("block_transactions",) | ||||
| command = b"blocktxn" | msgtype = b"blocktxn" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.block_transactions = BlockTransactions() | self.block_transactions = BlockTransactions() | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.block_transactions.deserialize(f) | self.block_transactions.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += self.block_transactions.serialize() | r += self.block_transactions.serialize() | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_blocktxn(block_transactions={})".format( | return "msg_blocktxn(block_transactions={})".format( | ||||
| repr(self.block_transactions)) | repr(self.block_transactions)) | ||||
| class msg_avapoll(): | class msg_avapoll(): | ||||
| __slots__ = ("poll",) | __slots__ = ("poll",) | ||||
| command = b"avapoll" | msgtype = b"avapoll" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.poll = AvalanchePoll() | self.poll = AvalanchePoll() | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.poll.deserialize(f) | self.poll.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += self.poll.serialize() | r += self.poll.serialize() | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_avapoll(poll={})".format(repr(self.poll)) | return "msg_avapoll(poll={})".format(repr(self.poll)) | ||||
| class msg_avaresponse(): | class msg_avaresponse(): | ||||
| __slots__ = ("response",) | __slots__ = ("response",) | ||||
| command = b"avaresponse" | msgtype = b"avaresponse" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.response = AvalancheResponse() | self.response = AvalancheResponse() | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.response.deserialize(f) | self.response.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += self.response.serialize() | r += self.response.serialize() | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_avaresponse(response={})".format(repr(self.response)) | return "msg_avaresponse(response={})".format(repr(self.response)) | ||||
| class msg_tcpavaresponse(): | class msg_tcpavaresponse(): | ||||
| __slots__ = ("response",) | __slots__ = ("response",) | ||||
| command = b"avaresponse" | msgtype = b"avaresponse" | ||||
| def __init__(self): | def __init__(self): | ||||
| self.response = TCPAvalancheResponse() | self.response = TCPAvalancheResponse() | ||||
| def deserialize(self, f): | def deserialize(self, f): | ||||
| self.response.deserialize(f) | self.response.deserialize(f) | ||||
| def serialize(self): | def serialize(self): | ||||
| r = b"" | r = b"" | ||||
| r += self.response.serialize() | r += self.response.serialize() | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return "msg_tcpavaresponse(response={})".format(repr(self.response)) | return "msg_tcpavaresponse(response={})".format(repr(self.response)) | ||||