1#!/usr/bin/env python3 2# Copyright (c) 2010 ArtForz -- public domain half-a-node 3# Copyright (c) 2012 Jeff Garzik 4# Copyright (c) 2010-2020 The Bitcoin Core developers 5# Distributed under the MIT software license, see the accompanying 6# file COPYING or http://www.opensource.org/licenses/mit-license.php. 7"""Bitcoin test framework primitive and message structures 8 9CBlock, CTransaction, CBlockHeader, CTxIn, CTxOut, etc....: 10 data structures that should map to corresponding structures in 11 bitcoin/primitives 12 13msg_block, msg_tx, msg_headers, etc.: 14 data structures that represent network messages 15 16ser_*, deser_*: functions that handle serialization/deserialization. 17 18Classes use __slots__ to ensure extraneous attributes aren't accidentally added 19by tests, compromising their intended effect. 20""" 21from codecs import encode 22import copy 23import hashlib 24from io import BytesIO 25import math 26import random 27import socket 28import struct 29import time 30 31from test_framework.siphash import siphash256 32from test_framework.util import hex_str_to_bytes, assert_equal 33 34MIN_VERSION_SUPPORTED = 60001 35MY_VERSION = 110016 # past wtxid relay 36MY_SUBVERSION = b"/python-p2p-tester:0.0.3/" 37MY_RELAY = 1 # from version 70001 onwards, fRelay should be appended to version messages (BIP37) 38 39MAX_LOCATOR_SZ = 101 40MAX_BLOCK_BASE_SIZE = 1000000 41MAX_BLOOM_FILTER_SIZE = 36000 42MAX_BLOOM_HASH_FUNCS = 50 43 44COIN = 100000000 # 1 btc in satoshis 45MAX_MONEY = 21000000 * COIN 46 47BIP125_SEQUENCE_NUMBER = 0xfffffffd # Sequence number that is BIP 125 opt-in and BIP 68-opt-out 48 49MAX_PROTOCOL_MESSAGE_LENGTH = 32 * 1024 * 1024 # Maximum length of incoming protocol messages 50MAX_HEADERS_RESULTS = 2000 # Number of headers sent in one getheaders result 51MAX_INV_SIZE = 50000 # Maximum number of entries in an 'inv' protocol message 52 53NODE_NETWORK = (1 << 0) 54NODE_GETUTXO = (1 << 1) 55NODE_BLOOM = (1 << 2) 56NODE_WITNESS = (1 << 3) 57NODE_COMPACT_FILTERS = (1 << 6) 58NODE_NETWORK_LIMITED = (1 << 10) 59 60MSG_TX = 1 61MSG_BLOCK = 2 62MSG_FILTERED_BLOCK = 3 63MSG_CMPCT_BLOCK = 4 64MSG_WTX = 5 65MSG_WITNESS_FLAG = 1 << 30 66MSG_TYPE_MASK = 0xffffffff >> 2 67MSG_WITNESS_TX = MSG_TX | MSG_WITNESS_FLAG 68 69FILTER_TYPE_BASIC = 0 70 71WITNESS_SCALE_FACTOR = 4 72 73# Constants for the auxpow block version. 74VERSION_AUXPOW = (1 << 8) 75VERSION_CHAIN_START = (1 << 16) 76CHAIN_ID = 1 77 78# Namecoin tx version 79NAMECOIN_TX_VERSION = 0x7100 80 81# Serialization/deserialization tools 82def sha256(s): 83 return hashlib.new('sha256', s).digest() 84 85def hash256(s): 86 return sha256(sha256(s)) 87 88def ser_compact_size(l): 89 r = b"" 90 if l < 253: 91 r = struct.pack("B", l) 92 elif l < 0x10000: 93 r = struct.pack("<BH", 253, l) 94 elif l < 0x100000000: 95 r = struct.pack("<BI", 254, l) 96 else: 97 r = struct.pack("<BQ", 255, l) 98 return r 99 100def deser_compact_size(f): 101 nit = struct.unpack("<B", f.read(1))[0] 102 if nit == 253: 103 nit = struct.unpack("<H", f.read(2))[0] 104 elif nit == 254: 105 nit = struct.unpack("<I", f.read(4))[0] 106 elif nit == 255: 107 nit = struct.unpack("<Q", f.read(8))[0] 108 return nit 109 110def deser_string(f): 111 nit = deser_compact_size(f) 112 return f.read(nit) 113 114def ser_string(s): 115 return ser_compact_size(len(s)) + s 116 117def deser_uint256(f): 118 r = 0 119 for i in range(8): 120 t = struct.unpack("<I", f.read(4))[0] 121 r += t << (i * 32) 122 return r 123 124 125def ser_uint256(u): 126 rs = b"" 127 for _ in range(8): 128 rs += struct.pack("<I", u & 0xFFFFFFFF) 129 u >>= 32 130 return rs 131 132 133def uint256_from_str(s): 134 r = 0 135 t = struct.unpack("<IIIIIIII", s[:32]) 136 for i in range(8): 137 r += t[i] << (i * 32) 138 return r 139 140 141def uint256_from_compact(c): 142 nbytes = (c >> 24) & 0xFF 143 v = (c & 0xFFFFFF) << (8 * (nbytes - 3)) 144 return v 145 146 147# deser_function_name: Allow for an alternate deserialization function on the 148# entries in the vector. 149def deser_vector(f, c, deser_function_name=None): 150 nit = deser_compact_size(f) 151 r = [] 152 for _ in range(nit): 153 t = c() 154 if deser_function_name: 155 getattr(t, deser_function_name)(f) 156 else: 157 t.deserialize(f) 158 r.append(t) 159 return r 160 161 162# ser_function_name: Allow for an alternate serialization function on the 163# entries in the vector (we use this for serializing the vector of transactions 164# for a witness block). 165def ser_vector(l, ser_function_name=None): 166 r = ser_compact_size(len(l)) 167 for i in l: 168 if ser_function_name: 169 r += getattr(i, ser_function_name)() 170 else: 171 r += i.serialize() 172 return r 173 174 175def deser_uint256_vector(f): 176 nit = deser_compact_size(f) 177 r = [] 178 for _ in range(nit): 179 t = deser_uint256(f) 180 r.append(t) 181 return r 182 183 184def ser_uint256_vector(l): 185 r = ser_compact_size(len(l)) 186 for i in l: 187 r += ser_uint256(i) 188 return r 189 190 191def deser_string_vector(f): 192 nit = deser_compact_size(f) 193 r = [] 194 for _ in range(nit): 195 t = deser_string(f) 196 r.append(t) 197 return r 198 199 200def ser_string_vector(l): 201 r = ser_compact_size(len(l)) 202 for sv in l: 203 r += ser_string(sv) 204 return r 205 206 207# Deserialize from a hex string representation (eg from RPC) 208def FromHex(obj, hex_string): 209 obj.deserialize(BytesIO(hex_str_to_bytes(hex_string))) 210 return obj 211 212# Convert a binary-serializable object to hex (eg for submission via RPC) 213def ToHex(obj): 214 return obj.serialize().hex() 215 216# Objects that map to bitcoind objects, which can be serialized/deserialized 217 218 219class CAddress: 220 __slots__ = ("net", "ip", "nServices", "port", "time") 221 222 # see https://github.com/bitcoin/bips/blob/master/bip-0155.mediawiki 223 NET_IPV4 = 1 224 225 ADDRV2_NET_NAME = { 226 NET_IPV4: "IPv4" 227 } 228 229 ADDRV2_ADDRESS_LENGTH = { 230 NET_IPV4: 4 231 } 232 233 def __init__(self): 234 self.time = 0 235 self.nServices = 1 236 self.net = self.NET_IPV4 237 self.ip = "0.0.0.0" 238 self.port = 0 239 240 def deserialize(self, f, *, with_time=True): 241 """Deserialize from addrv1 format (pre-BIP155)""" 242 if with_time: 243 # VERSION messages serialize CAddress objects without time 244 self.time = struct.unpack("<I", f.read(4))[0] 245 self.nServices = struct.unpack("<Q", f.read(8))[0] 246 # We only support IPv4 which means skip 12 bytes and read the next 4 as IPv4 address. 247 f.read(12) 248 self.net = self.NET_IPV4 249 self.ip = socket.inet_ntoa(f.read(4)) 250 self.port = struct.unpack(">H", f.read(2))[0] 251 252 def serialize(self, *, with_time=True): 253 """Serialize in addrv1 format (pre-BIP155)""" 254 assert self.net == self.NET_IPV4 255 r = b"" 256 if with_time: 257 # VERSION messages serialize CAddress objects without time 258 r += struct.pack("<I", self.time) 259 r += struct.pack("<Q", self.nServices) 260 r += b"\x00" * 10 + b"\xff" * 2 261 r += socket.inet_aton(self.ip) 262 r += struct.pack(">H", self.port) 263 return r 264 265 def deserialize_v2(self, f): 266 """Deserialize from addrv2 format (BIP155)""" 267 self.time = struct.unpack("<I", f.read(4))[0] 268 269 self.nServices = deser_compact_size(f) 270 271 self.net = struct.unpack("B", f.read(1))[0] 272 assert self.net == self.NET_IPV4 273 274 address_length = deser_compact_size(f) 275 assert address_length == self.ADDRV2_ADDRESS_LENGTH[self.net] 276 277 self.ip = socket.inet_ntoa(f.read(4)) 278 279 self.port = struct.unpack(">H", f.read(2))[0] 280 281 def serialize_v2(self): 282 """Serialize in addrv2 format (BIP155)""" 283 assert self.net == self.NET_IPV4 284 r = b"" 285 r += struct.pack("<I", self.time) 286 r += ser_compact_size(self.nServices) 287 r += struct.pack("B", self.net) 288 r += ser_compact_size(self.ADDRV2_ADDRESS_LENGTH[self.net]) 289 r += socket.inet_aton(self.ip) 290 r += struct.pack(">H", self.port) 291 return r 292 293 def __repr__(self): 294 return ("CAddress(nServices=%i net=%s addr=%s port=%i)" 295 % (self.nServices, self.ADDRV2_NET_NAME[self.net], self.ip, self.port)) 296 297 298class CInv: 299 __slots__ = ("hash", "type") 300 301 typemap = { 302 0: "Error", 303 MSG_TX: "TX", 304 MSG_BLOCK: "Block", 305 MSG_TX | MSG_WITNESS_FLAG: "WitnessTx", 306 MSG_BLOCK | MSG_WITNESS_FLAG: "WitnessBlock", 307 MSG_FILTERED_BLOCK: "filtered Block", 308 MSG_CMPCT_BLOCK: "CompactBlock", 309 MSG_WTX: "WTX", 310 } 311 312 def __init__(self, t=0, h=0): 313 self.type = t 314 self.hash = h 315 316 def deserialize(self, f): 317 self.type = struct.unpack("<I", f.read(4))[0] 318 self.hash = deser_uint256(f) 319 320 def serialize(self): 321 r = b"" 322 r += struct.pack("<I", self.type) 323 r += ser_uint256(self.hash) 324 return r 325 326 def __repr__(self): 327 return "CInv(type=%s hash=%064x)" \ 328 % (self.typemap[self.type], self.hash) 329 330 def __eq__(self, other): 331 return isinstance(other, CInv) and self.hash == other.hash and self.type == other.type 332 333 334class CBlockLocator: 335 __slots__ = ("nVersion", "vHave") 336 337 def __init__(self): 338 self.nVersion = MY_VERSION 339 self.vHave = [] 340 341 def deserialize(self, f): 342 self.nVersion = struct.unpack("<i", f.read(4))[0] 343 self.vHave = deser_uint256_vector(f) 344 345 def serialize(self): 346 r = b"" 347 r += struct.pack("<i", self.nVersion) 348 r += ser_uint256_vector(self.vHave) 349 return r 350 351 def __repr__(self): 352 return "CBlockLocator(nVersion=%i vHave=%s)" \ 353 % (self.nVersion, repr(self.vHave)) 354 355 356class COutPoint: 357 __slots__ = ("hash", "n") 358 359 def __init__(self, hash=0, n=0): 360 self.hash = hash 361 self.n = n 362 363 def deserialize(self, f): 364 self.hash = deser_uint256(f) 365 self.n = struct.unpack("<I", f.read(4))[0] 366 367 def serialize(self): 368 r = b"" 369 r += ser_uint256(self.hash) 370 r += struct.pack("<I", self.n) 371 return r 372 373 def __repr__(self): 374 return "COutPoint(hash=%064x n=%i)" % (self.hash, self.n) 375 376 377class CTxIn: 378 __slots__ = ("nSequence", "prevout", "scriptSig") 379 380 def __init__(self, outpoint=None, scriptSig=b"", nSequence=0): 381 if outpoint is None: 382 self.prevout = COutPoint() 383 else: 384 self.prevout = outpoint 385 self.scriptSig = scriptSig 386 self.nSequence = nSequence 387 388 def deserialize(self, f): 389 self.prevout = COutPoint() 390 self.prevout.deserialize(f) 391 self.scriptSig = deser_string(f) 392 self.nSequence = struct.unpack("<I", f.read(4))[0] 393 394 def serialize(self): 395 r = b"" 396 r += self.prevout.serialize() 397 r += ser_string(self.scriptSig) 398 r += struct.pack("<I", self.nSequence) 399 return r 400 401 def __repr__(self): 402 return "CTxIn(prevout=%s scriptSig=%s nSequence=%i)" \ 403 % (repr(self.prevout), self.scriptSig.hex(), 404 self.nSequence) 405 406 407class CTxOut: 408 __slots__ = ("nValue", "scriptPubKey") 409 410 def __init__(self, nValue=0, scriptPubKey=b""): 411 self.nValue = nValue 412 self.scriptPubKey = scriptPubKey 413 414 def deserialize(self, f): 415 self.nValue = struct.unpack("<q", f.read(8))[0] 416 self.scriptPubKey = deser_string(f) 417 418 def serialize(self): 419 r = b"" 420 r += struct.pack("<q", self.nValue) 421 r += ser_string(self.scriptPubKey) 422 return r 423 424 def __repr__(self): 425 return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" \ 426 % (self.nValue // COIN, self.nValue % COIN, 427 self.scriptPubKey.hex()) 428 429 430class CScriptWitness: 431 __slots__ = ("stack",) 432 433 def __init__(self): 434 # stack is a vector of strings 435 self.stack = [] 436 437 def __repr__(self): 438 return "CScriptWitness(%s)" % \ 439 (",".join([x.hex() for x in self.stack])) 440 441 def is_null(self): 442 if self.stack: 443 return False 444 return True 445 446 447class CTxInWitness: 448 __slots__ = ("scriptWitness",) 449 450 def __init__(self): 451 self.scriptWitness = CScriptWitness() 452 453 def deserialize(self, f): 454 self.scriptWitness.stack = deser_string_vector(f) 455 456 def serialize(self): 457 return ser_string_vector(self.scriptWitness.stack) 458 459 def __repr__(self): 460 return repr(self.scriptWitness) 461 462 def is_null(self): 463 return self.scriptWitness.is_null() 464 465 466class CTxWitness: 467 __slots__ = ("vtxinwit",) 468 469 def __init__(self): 470 self.vtxinwit = [] 471 472 def deserialize(self, f): 473 for i in range(len(self.vtxinwit)): 474 self.vtxinwit[i].deserialize(f) 475 476 def serialize(self): 477 r = b"" 478 # This is different than the usual vector serialization -- 479 # we omit the length of the vector, which is required to be 480 # the same length as the transaction's vin vector. 481 for x in self.vtxinwit: 482 r += x.serialize() 483 return r 484 485 def __repr__(self): 486 return "CTxWitness(%s)" % \ 487 (';'.join([repr(x) for x in self.vtxinwit])) 488 489 def is_null(self): 490 for x in self.vtxinwit: 491 if not x.is_null(): 492 return False 493 return True 494 495 496class CTransaction: 497 __slots__ = ("hash", "nLockTime", "nVersion", "sha256", "vin", "vout", 498 "wit") 499 500 def __init__(self, tx=None): 501 if tx is None: 502 self.nVersion = 1 503 self.vin = [] 504 self.vout = [] 505 self.wit = CTxWitness() 506 self.nLockTime = 0 507 self.sha256 = None 508 self.hash = None 509 else: 510 self.nVersion = tx.nVersion 511 self.vin = copy.deepcopy(tx.vin) 512 self.vout = copy.deepcopy(tx.vout) 513 self.nLockTime = tx.nLockTime 514 self.sha256 = tx.sha256 515 self.hash = tx.hash 516 self.wit = copy.deepcopy(tx.wit) 517 518 def deserialize(self, f): 519 self.nVersion = struct.unpack("<i", f.read(4))[0] 520 self.vin = deser_vector(f, CTxIn) 521 flags = 0 522 if len(self.vin) == 0: 523 flags = struct.unpack("<B", f.read(1))[0] 524 # Not sure why flags can't be zero, but this 525 # matches the implementation in bitcoind 526 if (flags != 0): 527 self.vin = deser_vector(f, CTxIn) 528 self.vout = deser_vector(f, CTxOut) 529 else: 530 self.vout = deser_vector(f, CTxOut) 531 if flags != 0: 532 self.wit.vtxinwit = [CTxInWitness() for _ in range(len(self.vin))] 533 self.wit.deserialize(f) 534 else: 535 self.wit = CTxWitness() 536 self.nLockTime = struct.unpack("<I", f.read(4))[0] 537 self.sha256 = None 538 self.hash = None 539 540 def serialize_without_witness(self): 541 r = b"" 542 r += struct.pack("<i", self.nVersion) 543 r += ser_vector(self.vin) 544 r += ser_vector(self.vout) 545 r += struct.pack("<I", self.nLockTime) 546 return r 547 548 # Only serialize with witness when explicitly called for 549 def serialize_with_witness(self): 550 flags = 0 551 if not self.wit.is_null(): 552 flags |= 1 553 r = b"" 554 r += struct.pack("<i", self.nVersion) 555 if flags: 556 dummy = [] 557 r += ser_vector(dummy) 558 r += struct.pack("<B", flags) 559 r += ser_vector(self.vin) 560 r += ser_vector(self.vout) 561 if flags & 1: 562 if (len(self.wit.vtxinwit) != len(self.vin)): 563 # vtxinwit must have the same length as vin 564 self.wit.vtxinwit = self.wit.vtxinwit[:len(self.vin)] 565 for _ in range(len(self.wit.vtxinwit), len(self.vin)): 566 self.wit.vtxinwit.append(CTxInWitness()) 567 r += self.wit.serialize() 568 r += struct.pack("<I", self.nLockTime) 569 return r 570 571 # Regular serialization is with witness -- must explicitly 572 # call serialize_without_witness to exclude witness data. 573 def serialize(self): 574 return self.serialize_with_witness() 575 576 # Recalculate the txid (transaction hash without witness) 577 def rehash(self): 578 self.sha256 = None 579 self.calc_sha256() 580 return self.hash 581 582 # We will only cache the serialization without witness in 583 # self.sha256 and self.hash -- those are expected to be the txid. 584 def calc_sha256(self, with_witness=False): 585 if with_witness: 586 # Don't cache the result, just return it 587 return uint256_from_str(hash256(self.serialize_with_witness())) 588 589 if self.sha256 is None: 590 self.sha256 = uint256_from_str(hash256(self.serialize_without_witness())) 591 self.hash = encode(hash256(self.serialize_without_witness())[::-1], 'hex_codec').decode('ascii') 592 593 def is_valid(self): 594 self.calc_sha256() 595 for tout in self.vout: 596 if tout.nValue < 0 or tout.nValue > 21000000 * COIN: 597 return False 598 return True 599 600 # Calculate the virtual transaction size using witness and non-witness 601 # serialization size (does NOT use sigops). 602 def get_vsize(self): 603 with_witness_size = len(self.serialize_with_witness()) 604 without_witness_size = len(self.serialize_without_witness()) 605 return math.ceil(((WITNESS_SCALE_FACTOR - 1) * without_witness_size + with_witness_size) / WITNESS_SCALE_FACTOR) 606 607 def __repr__(self): 608 return "CTransaction(nVersion=%i vin=%s vout=%s wit=%s nLockTime=%i)" \ 609 % (self.nVersion, repr(self.vin), repr(self.vout), repr(self.wit), self.nLockTime) 610 611 612class CAuxPow(CTransaction): 613 __slots__ = ("hashBlock", "vMerkleBranch", "nIndex", 614 "vChainMerkleBranch", "nChainIndex", "parentBlock") 615 616 def __init__(self): 617 super(CAuxPow, self).__init__() 618 self.hashBlock = 0 619 self.vMerkleBranch = [] 620 self.nIndex = 0 621 self.vChainMerkleBranch = [] 622 self.nChainIndex = 0 623 self.parentBlock = CBlockHeader() 624 625 def deserialize(self, f): 626 super(CAuxPow, self).deserialize(f) 627 self.hashBlock = deser_uint256(f) 628 self.vMerkleBranch = deser_uint256_vector(f) 629 self.nIndex = struct.unpack("<I", f.read(4))[0] 630 self.vChainMerkleBranch = deser_uint256_vector(f) 631 self.nChainIndex = struct.unpack("<I", f.read(4))[0] 632 self.parentBlock.deserialize(f) 633 634 def serialize(self): 635 r = b"" 636 r += super(CAuxPow, self).serialize() 637 r += ser_uint256(self.hashBlock) 638 r += ser_uint256_vector(self.vMerkleBranch) 639 r += struct.pack("<I", self.nIndex) 640 r += ser_uint256_vector(self.vChainMerkleBranch) 641 r += struct.pack("<I", self.nChainIndex) 642 r += self.parentBlock.serialize() 643 return r 644 645 646class CBlockHeader: 647 __slots__ = ("hash", "hashMerkleRoot", "hashPrevBlock", "nBits", "nNonce", 648 "auxpow", 649 "nTime", "nVersion", "sha256") 650 651 def __init__(self, header=None): 652 if header is None: 653 self.set_null() 654 else: 655 self.nVersion = header.nVersion 656 self.hashPrevBlock = header.hashPrevBlock 657 self.hashMerkleRoot = header.hashMerkleRoot 658 self.nTime = header.nTime 659 self.nBits = header.nBits 660 self.nNonce = header.nNonce 661 self.auxpow = header.auxpow 662 self.sha256 = header.sha256 663 self.hash = header.hash 664 self.calc_sha256() 665 666 def set_null(self): 667 # Set auxpow chain ID. Blocks without a chain ID are not accepted 668 # by the regtest network consensus rules (since they are "legacy"). 669 self.set_base_version(1) 670 671 self.hashPrevBlock = 0 672 self.hashMerkleRoot = 0 673 self.nTime = 0 674 self.nBits = 0 675 self.nNonce = 0 676 self.auxpow = None 677 self.sha256 = None 678 self.hash = None 679 680 def set_base_version(self, n): 681 assert n < VERSION_AUXPOW 682 self.nVersion = n + CHAIN_ID * VERSION_CHAIN_START 683 684 def mark_auxpow(self): 685 self.nVersion |= VERSION_AUXPOW 686 687 def is_auxpow(self): 688 return (self.nVersion & VERSION_AUXPOW) > 0 689 690 def deserialize(self, f): 691 self.nVersion = struct.unpack("<i", f.read(4))[0] 692 self.hashPrevBlock = deser_uint256(f) 693 self.hashMerkleRoot = deser_uint256(f) 694 self.nTime = struct.unpack("<I", f.read(4))[0] 695 self.nBits = struct.unpack("<I", f.read(4))[0] 696 self.nNonce = struct.unpack("<I", f.read(4))[0] 697 if self.is_auxpow(): 698 self.auxpow = CAuxPow() 699 self.auxpow.deserialize(f) 700 self.sha256 = None 701 self.hash = None 702 703 def serialize(self): 704 r = b"" 705 r += struct.pack("<i", self.nVersion) 706 r += ser_uint256(self.hashPrevBlock) 707 r += ser_uint256(self.hashMerkleRoot) 708 r += struct.pack("<I", self.nTime) 709 r += struct.pack("<I", self.nBits) 710 r += struct.pack("<I", self.nNonce) 711 if self.is_auxpow(): 712 r += self.auxpow.serialize() 713 return r 714 715 def calc_sha256(self): 716 if self.sha256 is None: 717 r = b"" 718 r += struct.pack("<i", self.nVersion) 719 r += ser_uint256(self.hashPrevBlock) 720 r += ser_uint256(self.hashMerkleRoot) 721 r += struct.pack("<I", self.nTime) 722 r += struct.pack("<I", self.nBits) 723 r += struct.pack("<I", self.nNonce) 724 self.sha256 = uint256_from_str(hash256(r)) 725 self.hash = encode(hash256(r)[::-1], 'hex_codec').decode('ascii') 726 727 def rehash(self): 728 self.sha256 = None 729 self.calc_sha256() 730 return self.sha256 731 732 def __repr__(self): 733 return "CBlockHeader(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)" \ 734 % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot, 735 time.ctime(self.nTime), self.nBits, self.nNonce) 736 737BLOCK_HEADER_SIZE = len(CBlockHeader().serialize()) 738assert_equal(BLOCK_HEADER_SIZE, 80) 739 740class CBlock(CBlockHeader): 741 __slots__ = ("vtx",) 742 743 def __init__(self, header=None): 744 super().__init__(header) 745 self.vtx = [] 746 747 def deserialize(self, f): 748 super().deserialize(f) 749 self.vtx = deser_vector(f, CTransaction) 750 751 def serialize(self, with_witness=True): 752 r = b"" 753 r += super().serialize() 754 if with_witness: 755 r += ser_vector(self.vtx, "serialize_with_witness") 756 else: 757 r += ser_vector(self.vtx, "serialize_without_witness") 758 return r 759 760 # Calculate the merkle root given a vector of transaction hashes 761 @classmethod 762 def get_merkle_root(cls, hashes): 763 while len(hashes) > 1: 764 newhashes = [] 765 for i in range(0, len(hashes), 2): 766 i2 = min(i+1, len(hashes)-1) 767 newhashes.append(hash256(hashes[i] + hashes[i2])) 768 hashes = newhashes 769 return uint256_from_str(hashes[0]) 770 771 def calc_merkle_root(self): 772 hashes = [] 773 for tx in self.vtx: 774 tx.calc_sha256() 775 hashes.append(ser_uint256(tx.sha256)) 776 return self.get_merkle_root(hashes) 777 778 def calc_witness_merkle_root(self): 779 # For witness root purposes, the hash of the 780 # coinbase, with witness, is defined to be 0...0 781 hashes = [ser_uint256(0)] 782 783 for tx in self.vtx[1:]: 784 # Calculate the hashes with witness data 785 hashes.append(ser_uint256(tx.calc_sha256(True))) 786 787 return self.get_merkle_root(hashes) 788 789 def is_valid(self): 790 self.calc_sha256() 791 target = uint256_from_compact(self.nBits) 792 793 # FIXME: Validation is not actually used anywhere. If it is in 794 # the future, need to implement basic auxpow checking. 795 assert not self.is_auxpow() 796 797 if self.sha256 > target: 798 return False 799 for tx in self.vtx: 800 if not tx.is_valid(): 801 return False 802 if self.calc_merkle_root() != self.hashMerkleRoot: 803 return False 804 return True 805 806 def solve(self): 807 self.rehash() 808 target = uint256_from_compact(self.nBits) 809 while self.sha256 > target: 810 self.nNonce += 1 811 self.rehash() 812 813 def __repr__(self): 814 return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%s)" \ 815 % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot, 816 time.ctime(self.nTime), self.nBits, self.nNonce, repr(self.vtx)) 817 818 819class PrefilledTransaction: 820 __slots__ = ("index", "tx") 821 822 def __init__(self, index=0, tx = None): 823 self.index = index 824 self.tx = tx 825 826 def deserialize(self, f): 827 self.index = deser_compact_size(f) 828 self.tx = CTransaction() 829 self.tx.deserialize(f) 830 831 def serialize(self, with_witness=True): 832 r = b"" 833 r += ser_compact_size(self.index) 834 if with_witness: 835 r += self.tx.serialize_with_witness() 836 else: 837 r += self.tx.serialize_without_witness() 838 return r 839 840 def serialize_without_witness(self): 841 return self.serialize(with_witness=False) 842 843 def serialize_with_witness(self): 844 return self.serialize(with_witness=True) 845 846 def __repr__(self): 847 return "PrefilledTransaction(index=%d, tx=%s)" % (self.index, repr(self.tx)) 848 849 850# This is what we send on the wire, in a cmpctblock message. 851class P2PHeaderAndShortIDs: 852 __slots__ = ("header", "nonce", "prefilled_txn", "prefilled_txn_length", 853 "shortids", "shortids_length") 854 855 def __init__(self): 856 self.header = CBlockHeader() 857 self.nonce = 0 858 self.shortids_length = 0 859 self.shortids = [] 860 self.prefilled_txn_length = 0 861 self.prefilled_txn = [] 862 863 def deserialize(self, f): 864 self.header.deserialize(f) 865 self.nonce = struct.unpack("<Q", f.read(8))[0] 866 self.shortids_length = deser_compact_size(f) 867 for _ in range(self.shortids_length): 868 # shortids are defined to be 6 bytes in the spec, so append 869 # two zero bytes and read it in as an 8-byte number 870 self.shortids.append(struct.unpack("<Q", f.read(6) + b'\x00\x00')[0]) 871 self.prefilled_txn = deser_vector(f, PrefilledTransaction) 872 self.prefilled_txn_length = len(self.prefilled_txn) 873 874 # When using version 2 compact blocks, we must serialize with_witness. 875 def serialize(self, with_witness=False): 876 r = b"" 877 r += self.header.serialize() 878 r += struct.pack("<Q", self.nonce) 879 r += ser_compact_size(self.shortids_length) 880 for x in self.shortids: 881 # We only want the first 6 bytes 882 r += struct.pack("<Q", x)[0:6] 883 if with_witness: 884 r += ser_vector(self.prefilled_txn, "serialize_with_witness") 885 else: 886 r += ser_vector(self.prefilled_txn, "serialize_without_witness") 887 return r 888 889 def __repr__(self): 890 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)) 891 892 893# P2P version of the above that will use witness serialization (for compact 894# block version 2) 895class P2PHeaderAndShortWitnessIDs(P2PHeaderAndShortIDs): 896 __slots__ = () 897 def serialize(self): 898 return super().serialize(with_witness=True) 899 900# Calculate the BIP 152-compact blocks shortid for a given transaction hash 901def calculate_shortid(k0, k1, tx_hash): 902 expected_shortid = siphash256(k0, k1, tx_hash) 903 expected_shortid &= 0x0000ffffffffffff 904 return expected_shortid 905 906 907# This version gets rid of the array lengths, and reinterprets the differential 908# encoding into indices that can be used for lookup. 909class HeaderAndShortIDs: 910 __slots__ = ("header", "nonce", "prefilled_txn", "shortids", "use_witness") 911 912 def __init__(self, p2pheaders_and_shortids = None): 913 self.header = CBlockHeader() 914 self.nonce = 0 915 self.shortids = [] 916 self.prefilled_txn = [] 917 self.use_witness = False 918 919 if p2pheaders_and_shortids is not None: 920 self.header = p2pheaders_and_shortids.header 921 self.nonce = p2pheaders_and_shortids.nonce 922 self.shortids = p2pheaders_and_shortids.shortids 923 last_index = -1 924 for x in p2pheaders_and_shortids.prefilled_txn: 925 self.prefilled_txn.append(PrefilledTransaction(x.index + last_index + 1, x.tx)) 926 last_index = self.prefilled_txn[-1].index 927 928 def to_p2p(self): 929 if self.use_witness: 930 ret = P2PHeaderAndShortWitnessIDs() 931 else: 932 ret = P2PHeaderAndShortIDs() 933 ret.header = self.header 934 ret.nonce = self.nonce 935 ret.shortids_length = len(self.shortids) 936 ret.shortids = self.shortids 937 ret.prefilled_txn_length = len(self.prefilled_txn) 938 ret.prefilled_txn = [] 939 last_index = -1 940 for x in self.prefilled_txn: 941 ret.prefilled_txn.append(PrefilledTransaction(x.index - last_index - 1, x.tx)) 942 last_index = x.index 943 return ret 944 945 def get_siphash_keys(self): 946 header_nonce = self.header.serialize() 947 header_nonce += struct.pack("<Q", self.nonce) 948 hash_header_nonce_as_str = sha256(header_nonce) 949 key0 = struct.unpack("<Q", hash_header_nonce_as_str[0:8])[0] 950 key1 = struct.unpack("<Q", hash_header_nonce_as_str[8:16])[0] 951 return [ key0, key1 ] 952 953 # Version 2 compact blocks use wtxid in shortids (rather than txid) 954 def initialize_from_block(self, block, nonce=0, prefill_list=None, use_witness=False): 955 if prefill_list is None: 956 prefill_list = [0] 957 self.header = CBlockHeader(block) 958 self.nonce = nonce 959 self.prefilled_txn = [ PrefilledTransaction(i, block.vtx[i]) for i in prefill_list ] 960 self.shortids = [] 961 self.use_witness = use_witness 962 [k0, k1] = self.get_siphash_keys() 963 for i in range(len(block.vtx)): 964 if i not in prefill_list: 965 tx_hash = block.vtx[i].sha256 966 if use_witness: 967 tx_hash = block.vtx[i].calc_sha256(with_witness=True) 968 self.shortids.append(calculate_shortid(k0, k1, tx_hash)) 969 970 def __repr__(self): 971 return "HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s" % (repr(self.header), self.nonce, repr(self.shortids), repr(self.prefilled_txn)) 972 973 974class BlockTransactionsRequest: 975 __slots__ = ("blockhash", "indexes") 976 977 def __init__(self, blockhash=0, indexes = None): 978 self.blockhash = blockhash 979 self.indexes = indexes if indexes is not None else [] 980 981 def deserialize(self, f): 982 self.blockhash = deser_uint256(f) 983 indexes_length = deser_compact_size(f) 984 for _ in range(indexes_length): 985 self.indexes.append(deser_compact_size(f)) 986 987 def serialize(self): 988 r = b"" 989 r += ser_uint256(self.blockhash) 990 r += ser_compact_size(len(self.indexes)) 991 for x in self.indexes: 992 r += ser_compact_size(x) 993 return r 994 995 # helper to set the differentially encoded indexes from absolute ones 996 def from_absolute(self, absolute_indexes): 997 self.indexes = [] 998 last_index = -1 999 for x in absolute_indexes: 1000 self.indexes.append(x-last_index-1) 1001 last_index = x 1002 1003 def to_absolute(self): 1004 absolute_indexes = [] 1005 last_index = -1 1006 for x in self.indexes: 1007 absolute_indexes.append(x+last_index+1) 1008 last_index = absolute_indexes[-1] 1009 return absolute_indexes 1010 1011 def __repr__(self): 1012 return "BlockTransactionsRequest(hash=%064x indexes=%s)" % (self.blockhash, repr(self.indexes)) 1013 1014 1015class BlockTransactions: 1016 __slots__ = ("blockhash", "transactions") 1017 1018 def __init__(self, blockhash=0, transactions = None): 1019 self.blockhash = blockhash 1020 self.transactions = transactions if transactions is not None else [] 1021 1022 def deserialize(self, f): 1023 self.blockhash = deser_uint256(f) 1024 self.transactions = deser_vector(f, CTransaction) 1025 1026 def serialize(self, with_witness=True): 1027 r = b"" 1028 r += ser_uint256(self.blockhash) 1029 if with_witness: 1030 r += ser_vector(self.transactions, "serialize_with_witness") 1031 else: 1032 r += ser_vector(self.transactions, "serialize_without_witness") 1033 return r 1034 1035 def __repr__(self): 1036 return "BlockTransactions(hash=%064x transactions=%s)" % (self.blockhash, repr(self.transactions)) 1037 1038 1039class CPartialMerkleTree: 1040 __slots__ = ("nTransactions", "vBits", "vHash") 1041 1042 def __init__(self): 1043 self.nTransactions = 0 1044 self.vHash = [] 1045 self.vBits = [] 1046 1047 def deserialize(self, f): 1048 self.nTransactions = struct.unpack("<i", f.read(4))[0] 1049 self.vHash = deser_uint256_vector(f) 1050 vBytes = deser_string(f) 1051 self.vBits = [] 1052 for i in range(len(vBytes) * 8): 1053 self.vBits.append(vBytes[i//8] & (1 << (i % 8)) != 0) 1054 1055 def serialize(self): 1056 r = b"" 1057 r += struct.pack("<i", self.nTransactions) 1058 r += ser_uint256_vector(self.vHash) 1059 vBytesArray = bytearray([0x00] * ((len(self.vBits) + 7)//8)) 1060 for i in range(len(self.vBits)): 1061 vBytesArray[i // 8] |= self.vBits[i] << (i % 8) 1062 r += ser_string(bytes(vBytesArray)) 1063 return r 1064 1065 def __repr__(self): 1066 return "CPartialMerkleTree(nTransactions=%d, vHash=%s, vBits=%s)" % (self.nTransactions, repr(self.vHash), repr(self.vBits)) 1067 1068 1069class CMerkleBlock: 1070 __slots__ = ("header", "txn") 1071 1072 def __init__(self): 1073 self.header = CBlockHeader() 1074 self.txn = CPartialMerkleTree() 1075 1076 def deserialize(self, f): 1077 self.header.deserialize(f) 1078 self.txn.deserialize(f) 1079 1080 def serialize(self): 1081 r = b"" 1082 r += self.header.serialize() 1083 r += self.txn.serialize() 1084 return r 1085 1086 def __repr__(self): 1087 return "CMerkleBlock(header=%s, txn=%s)" % (repr(self.header), repr(self.txn)) 1088 1089 1090# Objects that correspond to messages on the wire 1091class msg_version: 1092 __slots__ = ("addrFrom", "addrTo", "nNonce", "nRelay", "nServices", 1093 "nStartingHeight", "nTime", "nVersion", "strSubVer") 1094 msgtype = b"version" 1095 1096 def __init__(self): 1097 self.nVersion = MY_VERSION 1098 self.nServices = NODE_NETWORK | NODE_WITNESS 1099 self.nTime = int(time.time()) 1100 self.addrTo = CAddress() 1101 self.addrFrom = CAddress() 1102 self.nNonce = random.getrandbits(64) 1103 self.strSubVer = MY_SUBVERSION 1104 self.nStartingHeight = -1 1105 self.nRelay = MY_RELAY 1106 1107 def deserialize(self, f): 1108 self.nVersion = struct.unpack("<i", f.read(4))[0] 1109 self.nServices = struct.unpack("<Q", f.read(8))[0] 1110 self.nTime = struct.unpack("<q", f.read(8))[0] 1111 self.addrTo = CAddress() 1112 self.addrTo.deserialize(f, with_time=False) 1113 1114 self.addrFrom = CAddress() 1115 self.addrFrom.deserialize(f, with_time=False) 1116 self.nNonce = struct.unpack("<Q", f.read(8))[0] 1117 self.strSubVer = deser_string(f) 1118 1119 self.nStartingHeight = struct.unpack("<i", f.read(4))[0] 1120 1121 if self.nVersion >= 70001: 1122 # Relay field is optional for version 70001 onwards 1123 try: 1124 self.nRelay = struct.unpack("<b", f.read(1))[0] 1125 except: 1126 self.nRelay = 0 1127 else: 1128 self.nRelay = 0 1129 1130 def serialize(self): 1131 r = b"" 1132 r += struct.pack("<i", self.nVersion) 1133 r += struct.pack("<Q", self.nServices) 1134 r += struct.pack("<q", self.nTime) 1135 r += self.addrTo.serialize(with_time=False) 1136 r += self.addrFrom.serialize(with_time=False) 1137 r += struct.pack("<Q", self.nNonce) 1138 r += ser_string(self.strSubVer) 1139 r += struct.pack("<i", self.nStartingHeight) 1140 r += struct.pack("<b", self.nRelay) 1141 return r 1142 1143 def __repr__(self): 1144 return 'msg_version(nVersion=%i nServices=%i nTime=%s addrTo=%s addrFrom=%s nNonce=0x%016X strSubVer=%s nStartingHeight=%i nRelay=%i)' \ 1145 % (self.nVersion, self.nServices, time.ctime(self.nTime), 1146 repr(self.addrTo), repr(self.addrFrom), self.nNonce, 1147 self.strSubVer, self.nStartingHeight, self.nRelay) 1148 1149 1150class msg_verack: 1151 __slots__ = () 1152 msgtype = b"verack" 1153 1154 def __init__(self): 1155 pass 1156 1157 def deserialize(self, f): 1158 pass 1159 1160 def serialize(self): 1161 return b"" 1162 1163 def __repr__(self): 1164 return "msg_verack()" 1165 1166 1167class msg_addr: 1168 __slots__ = ("addrs",) 1169 msgtype = b"addr" 1170 1171 def __init__(self): 1172 self.addrs = [] 1173 1174 def deserialize(self, f): 1175 self.addrs = deser_vector(f, CAddress) 1176 1177 def serialize(self): 1178 return ser_vector(self.addrs) 1179 1180 def __repr__(self): 1181 return "msg_addr(addrs=%s)" % (repr(self.addrs)) 1182 1183 1184class msg_addrv2: 1185 __slots__ = ("addrs",) 1186 msgtype = b"addrv2" 1187 1188 def __init__(self): 1189 self.addrs = [] 1190 1191 def deserialize(self, f): 1192 self.addrs = deser_vector(f, CAddress, "deserialize_v2") 1193 1194 def serialize(self): 1195 return ser_vector(self.addrs, "serialize_v2") 1196 1197 def __repr__(self): 1198 return "msg_addrv2(addrs=%s)" % (repr(self.addrs)) 1199 1200 1201class msg_sendaddrv2: 1202 __slots__ = () 1203 msgtype = b"sendaddrv2" 1204 1205 def __init__(self): 1206 pass 1207 1208 def deserialize(self, f): 1209 pass 1210 1211 def serialize(self): 1212 return b"" 1213 1214 def __repr__(self): 1215 return "msg_sendaddrv2()" 1216 1217 1218class msg_inv: 1219 __slots__ = ("inv",) 1220 msgtype = b"inv" 1221 1222 def __init__(self, inv=None): 1223 if inv is None: 1224 self.inv = [] 1225 else: 1226 self.inv = inv 1227 1228 def deserialize(self, f): 1229 self.inv = deser_vector(f, CInv) 1230 1231 def serialize(self): 1232 return ser_vector(self.inv) 1233 1234 def __repr__(self): 1235 return "msg_inv(inv=%s)" % (repr(self.inv)) 1236 1237 1238class msg_getdata: 1239 __slots__ = ("inv",) 1240 msgtype = b"getdata" 1241 1242 def __init__(self, inv=None): 1243 self.inv = inv if inv is not None else [] 1244 1245 def deserialize(self, f): 1246 self.inv = deser_vector(f, CInv) 1247 1248 def serialize(self): 1249 return ser_vector(self.inv) 1250 1251 def __repr__(self): 1252 return "msg_getdata(inv=%s)" % (repr(self.inv)) 1253 1254 1255class msg_getblocks: 1256 __slots__ = ("locator", "hashstop") 1257 msgtype = b"getblocks" 1258 1259 def __init__(self): 1260 self.locator = CBlockLocator() 1261 self.hashstop = 0 1262 1263 def deserialize(self, f): 1264 self.locator = CBlockLocator() 1265 self.locator.deserialize(f) 1266 self.hashstop = deser_uint256(f) 1267 1268 def serialize(self): 1269 r = b"" 1270 r += self.locator.serialize() 1271 r += ser_uint256(self.hashstop) 1272 return r 1273 1274 def __repr__(self): 1275 return "msg_getblocks(locator=%s hashstop=%064x)" \ 1276 % (repr(self.locator), self.hashstop) 1277 1278 1279class msg_tx: 1280 __slots__ = ("tx",) 1281 msgtype = b"tx" 1282 1283 def __init__(self, tx=CTransaction()): 1284 self.tx = tx 1285 1286 def deserialize(self, f): 1287 self.tx.deserialize(f) 1288 1289 def serialize(self): 1290 return self.tx.serialize_with_witness() 1291 1292 def __repr__(self): 1293 return "msg_tx(tx=%s)" % (repr(self.tx)) 1294 1295class msg_wtxidrelay: 1296 __slots__ = () 1297 msgtype = b"wtxidrelay" 1298 1299 def __init__(self): 1300 pass 1301 1302 def deserialize(self, f): 1303 pass 1304 1305 def serialize(self): 1306 return b"" 1307 1308 def __repr__(self): 1309 return "msg_wtxidrelay()" 1310 1311 1312class msg_no_witness_tx(msg_tx): 1313 __slots__ = () 1314 1315 def serialize(self): 1316 return self.tx.serialize_without_witness() 1317 1318 1319class msg_block: 1320 __slots__ = ("block",) 1321 msgtype = b"block" 1322 1323 def __init__(self, block=None): 1324 if block is None: 1325 self.block = CBlock() 1326 else: 1327 self.block = block 1328 1329 def deserialize(self, f): 1330 self.block.deserialize(f) 1331 1332 def serialize(self): 1333 return self.block.serialize() 1334 1335 def __repr__(self): 1336 return "msg_block(block=%s)" % (repr(self.block)) 1337 1338 1339# for cases where a user needs tighter control over what is sent over the wire 1340# note that the user must supply the name of the msgtype, and the data 1341class msg_generic: 1342 __slots__ = ("msgtype", "data") 1343 1344 def __init__(self, msgtype, data=None): 1345 self.msgtype = msgtype 1346 self.data = data 1347 1348 def serialize(self): 1349 return self.data 1350 1351 def __repr__(self): 1352 return "msg_generic()" 1353 1354 1355class msg_no_witness_block(msg_block): 1356 __slots__ = () 1357 def serialize(self): 1358 return self.block.serialize(with_witness=False) 1359 1360 1361class msg_getaddr: 1362 __slots__ = () 1363 msgtype = b"getaddr" 1364 1365 def __init__(self): 1366 pass 1367 1368 def deserialize(self, f): 1369 pass 1370 1371 def serialize(self): 1372 return b"" 1373 1374 def __repr__(self): 1375 return "msg_getaddr()" 1376 1377 1378class msg_ping: 1379 __slots__ = ("nonce",) 1380 msgtype = b"ping" 1381 1382 def __init__(self, nonce=0): 1383 self.nonce = nonce 1384 1385 def deserialize(self, f): 1386 self.nonce = struct.unpack("<Q", f.read(8))[0] 1387 1388 def serialize(self): 1389 r = b"" 1390 r += struct.pack("<Q", self.nonce) 1391 return r 1392 1393 def __repr__(self): 1394 return "msg_ping(nonce=%08x)" % self.nonce 1395 1396 1397class msg_pong: 1398 __slots__ = ("nonce",) 1399 msgtype = b"pong" 1400 1401 def __init__(self, nonce=0): 1402 self.nonce = nonce 1403 1404 def deserialize(self, f): 1405 self.nonce = struct.unpack("<Q", f.read(8))[0] 1406 1407 def serialize(self): 1408 r = b"" 1409 r += struct.pack("<Q", self.nonce) 1410 return r 1411 1412 def __repr__(self): 1413 return "msg_pong(nonce=%08x)" % self.nonce 1414 1415 1416class msg_mempool: 1417 __slots__ = () 1418 msgtype = b"mempool" 1419 1420 def __init__(self): 1421 pass 1422 1423 def deserialize(self, f): 1424 pass 1425 1426 def serialize(self): 1427 return b"" 1428 1429 def __repr__(self): 1430 return "msg_mempool()" 1431 1432 1433class msg_notfound: 1434 __slots__ = ("vec", ) 1435 msgtype = b"notfound" 1436 1437 def __init__(self, vec=None): 1438 self.vec = vec or [] 1439 1440 def deserialize(self, f): 1441 self.vec = deser_vector(f, CInv) 1442 1443 def serialize(self): 1444 return ser_vector(self.vec) 1445 1446 def __repr__(self): 1447 return "msg_notfound(vec=%s)" % (repr(self.vec)) 1448 1449 1450class msg_sendheaders: 1451 __slots__ = () 1452 msgtype = b"sendheaders" 1453 1454 def __init__(self): 1455 pass 1456 1457 def deserialize(self, f): 1458 pass 1459 1460 def serialize(self): 1461 return b"" 1462 1463 def __repr__(self): 1464 return "msg_sendheaders()" 1465 1466 1467# getheaders message has 1468# number of entries 1469# vector of hashes 1470# hash_stop (hash of last desired block header, 0 to get as many as possible) 1471class msg_getheaders: 1472 __slots__ = ("hashstop", "locator",) 1473 msgtype = b"getheaders" 1474 1475 def __init__(self): 1476 self.locator = CBlockLocator() 1477 self.hashstop = 0 1478 1479 def deserialize(self, f): 1480 self.locator = CBlockLocator() 1481 self.locator.deserialize(f) 1482 self.hashstop = deser_uint256(f) 1483 1484 def serialize(self): 1485 r = b"" 1486 r += self.locator.serialize() 1487 r += ser_uint256(self.hashstop) 1488 return r 1489 1490 def __repr__(self): 1491 return "msg_getheaders(locator=%s, stop=%064x)" \ 1492 % (repr(self.locator), self.hashstop) 1493 1494 1495# headers message has 1496# <count> <vector of block headers> 1497class msg_headers: 1498 __slots__ = ("headers",) 1499 msgtype = b"headers" 1500 1501 def __init__(self, headers=None): 1502 self.headers = headers if headers is not None else [] 1503 1504 def deserialize(self, f): 1505 # comment in bitcoind indicates these should be deserialized as blocks 1506 blocks = deser_vector(f, CBlock) 1507 for x in blocks: 1508 self.headers.append(CBlockHeader(x)) 1509 1510 def serialize(self): 1511 blocks = [CBlock(x) for x in self.headers] 1512 return ser_vector(blocks) 1513 1514 def __repr__(self): 1515 return "msg_headers(headers=%s)" % repr(self.headers) 1516 1517 1518class msg_merkleblock: 1519 __slots__ = ("merkleblock",) 1520 msgtype = b"merkleblock" 1521 1522 def __init__(self, merkleblock=None): 1523 if merkleblock is None: 1524 self.merkleblock = CMerkleBlock() 1525 else: 1526 self.merkleblock = merkleblock 1527 1528 def deserialize(self, f): 1529 self.merkleblock.deserialize(f) 1530 1531 def serialize(self): 1532 return self.merkleblock.serialize() 1533 1534 def __repr__(self): 1535 return "msg_merkleblock(merkleblock=%s)" % (repr(self.merkleblock)) 1536 1537 1538class msg_filterload: 1539 __slots__ = ("data", "nHashFuncs", "nTweak", "nFlags") 1540 msgtype = b"filterload" 1541 1542 def __init__(self, data=b'00', nHashFuncs=0, nTweak=0, nFlags=0): 1543 self.data = data 1544 self.nHashFuncs = nHashFuncs 1545 self.nTweak = nTweak 1546 self.nFlags = nFlags 1547 1548 def deserialize(self, f): 1549 self.data = deser_string(f) 1550 self.nHashFuncs = struct.unpack("<I", f.read(4))[0] 1551 self.nTweak = struct.unpack("<I", f.read(4))[0] 1552 self.nFlags = struct.unpack("<B", f.read(1))[0] 1553 1554 def serialize(self): 1555 r = b"" 1556 r += ser_string(self.data) 1557 r += struct.pack("<I", self.nHashFuncs) 1558 r += struct.pack("<I", self.nTweak) 1559 r += struct.pack("<B", self.nFlags) 1560 return r 1561 1562 def __repr__(self): 1563 return "msg_filterload(data={}, nHashFuncs={}, nTweak={}, nFlags={})".format( 1564 self.data, self.nHashFuncs, self.nTweak, self.nFlags) 1565 1566 1567class msg_filteradd: 1568 __slots__ = ("data") 1569 msgtype = b"filteradd" 1570 1571 def __init__(self, data): 1572 self.data = data 1573 1574 def deserialize(self, f): 1575 self.data = deser_string(f) 1576 1577 def serialize(self): 1578 r = b"" 1579 r += ser_string(self.data) 1580 return r 1581 1582 def __repr__(self): 1583 return "msg_filteradd(data={})".format(self.data) 1584 1585 1586class msg_filterclear: 1587 __slots__ = () 1588 msgtype = b"filterclear" 1589 1590 def __init__(self): 1591 pass 1592 1593 def deserialize(self, f): 1594 pass 1595 1596 def serialize(self): 1597 return b"" 1598 1599 def __repr__(self): 1600 return "msg_filterclear()" 1601 1602 1603class msg_feefilter: 1604 __slots__ = ("feerate",) 1605 msgtype = b"feefilter" 1606 1607 def __init__(self, feerate=0): 1608 self.feerate = feerate 1609 1610 def deserialize(self, f): 1611 self.feerate = struct.unpack("<Q", f.read(8))[0] 1612 1613 def serialize(self): 1614 r = b"" 1615 r += struct.pack("<Q", self.feerate) 1616 return r 1617 1618 def __repr__(self): 1619 return "msg_feefilter(feerate=%08x)" % self.feerate 1620 1621 1622class msg_sendcmpct: 1623 __slots__ = ("announce", "version") 1624 msgtype = b"sendcmpct" 1625 1626 def __init__(self, announce=False, version=1): 1627 self.announce = announce 1628 self.version = version 1629 1630 def deserialize(self, f): 1631 self.announce = struct.unpack("<?", f.read(1))[0] 1632 self.version = struct.unpack("<Q", f.read(8))[0] 1633 1634 def serialize(self): 1635 r = b"" 1636 r += struct.pack("<?", self.announce) 1637 r += struct.pack("<Q", self.version) 1638 return r 1639 1640 def __repr__(self): 1641 return "msg_sendcmpct(announce=%s, version=%lu)" % (self.announce, self.version) 1642 1643 1644class msg_cmpctblock: 1645 __slots__ = ("header_and_shortids",) 1646 msgtype = b"cmpctblock" 1647 1648 def __init__(self, header_and_shortids = None): 1649 self.header_and_shortids = header_and_shortids 1650 1651 def deserialize(self, f): 1652 self.header_and_shortids = P2PHeaderAndShortIDs() 1653 self.header_and_shortids.deserialize(f) 1654 1655 def serialize(self): 1656 r = b"" 1657 r += self.header_and_shortids.serialize() 1658 return r 1659 1660 def __repr__(self): 1661 return "msg_cmpctblock(HeaderAndShortIDs=%s)" % repr(self.header_and_shortids) 1662 1663 1664class msg_getblocktxn: 1665 __slots__ = ("block_txn_request",) 1666 msgtype = b"getblocktxn" 1667 1668 def __init__(self): 1669 self.block_txn_request = None 1670 1671 def deserialize(self, f): 1672 self.block_txn_request = BlockTransactionsRequest() 1673 self.block_txn_request.deserialize(f) 1674 1675 def serialize(self): 1676 r = b"" 1677 r += self.block_txn_request.serialize() 1678 return r 1679 1680 def __repr__(self): 1681 return "msg_getblocktxn(block_txn_request=%s)" % (repr(self.block_txn_request)) 1682 1683 1684class msg_blocktxn: 1685 __slots__ = ("block_transactions",) 1686 msgtype = b"blocktxn" 1687 1688 def __init__(self): 1689 self.block_transactions = BlockTransactions() 1690 1691 def deserialize(self, f): 1692 self.block_transactions.deserialize(f) 1693 1694 def serialize(self): 1695 r = b"" 1696 r += self.block_transactions.serialize() 1697 return r 1698 1699 def __repr__(self): 1700 return "msg_blocktxn(block_transactions=%s)" % (repr(self.block_transactions)) 1701 1702 1703class msg_no_witness_blocktxn(msg_blocktxn): 1704 __slots__ = () 1705 1706 def serialize(self): 1707 return self.block_transactions.serialize(with_witness=False) 1708 1709 1710class msg_getcfilters: 1711 __slots__ = ("filter_type", "start_height", "stop_hash") 1712 msgtype = b"getcfilters" 1713 1714 def __init__(self, filter_type, start_height, stop_hash): 1715 self.filter_type = filter_type 1716 self.start_height = start_height 1717 self.stop_hash = stop_hash 1718 1719 def deserialize(self, f): 1720 self.filter_type = struct.unpack("<B", f.read(1))[0] 1721 self.start_height = struct.unpack("<I", f.read(4))[0] 1722 self.stop_hash = deser_uint256(f) 1723 1724 def serialize(self): 1725 r = b"" 1726 r += struct.pack("<B", self.filter_type) 1727 r += struct.pack("<I", self.start_height) 1728 r += ser_uint256(self.stop_hash) 1729 return r 1730 1731 def __repr__(self): 1732 return "msg_getcfilters(filter_type={:#x}, start_height={}, stop_hash={:x})".format( 1733 self.filter_type, self.start_height, self.stop_hash) 1734 1735class msg_cfilter: 1736 __slots__ = ("filter_type", "block_hash", "filter_data") 1737 msgtype = b"cfilter" 1738 1739 def __init__(self, filter_type=None, block_hash=None, filter_data=None): 1740 self.filter_type = filter_type 1741 self.block_hash = block_hash 1742 self.filter_data = filter_data 1743 1744 def deserialize(self, f): 1745 self.filter_type = struct.unpack("<B", f.read(1))[0] 1746 self.block_hash = deser_uint256(f) 1747 self.filter_data = deser_string(f) 1748 1749 def serialize(self): 1750 r = b"" 1751 r += struct.pack("<B", self.filter_type) 1752 r += ser_uint256(self.block_hash) 1753 r += ser_string(self.filter_data) 1754 return r 1755 1756 def __repr__(self): 1757 return "msg_cfilter(filter_type={:#x}, block_hash={:x})".format( 1758 self.filter_type, self.block_hash) 1759 1760class msg_getcfheaders: 1761 __slots__ = ("filter_type", "start_height", "stop_hash") 1762 msgtype = b"getcfheaders" 1763 1764 def __init__(self, filter_type, start_height, stop_hash): 1765 self.filter_type = filter_type 1766 self.start_height = start_height 1767 self.stop_hash = stop_hash 1768 1769 def deserialize(self, f): 1770 self.filter_type = struct.unpack("<B", f.read(1))[0] 1771 self.start_height = struct.unpack("<I", f.read(4))[0] 1772 self.stop_hash = deser_uint256(f) 1773 1774 def serialize(self): 1775 r = b"" 1776 r += struct.pack("<B", self.filter_type) 1777 r += struct.pack("<I", self.start_height) 1778 r += ser_uint256(self.stop_hash) 1779 return r 1780 1781 def __repr__(self): 1782 return "msg_getcfheaders(filter_type={:#x}, start_height={}, stop_hash={:x})".format( 1783 self.filter_type, self.start_height, self.stop_hash) 1784 1785class msg_cfheaders: 1786 __slots__ = ("filter_type", "stop_hash", "prev_header", "hashes") 1787 msgtype = b"cfheaders" 1788 1789 def __init__(self, filter_type=None, stop_hash=None, prev_header=None, hashes=None): 1790 self.filter_type = filter_type 1791 self.stop_hash = stop_hash 1792 self.prev_header = prev_header 1793 self.hashes = hashes 1794 1795 def deserialize(self, f): 1796 self.filter_type = struct.unpack("<B", f.read(1))[0] 1797 self.stop_hash = deser_uint256(f) 1798 self.prev_header = deser_uint256(f) 1799 self.hashes = deser_uint256_vector(f) 1800 1801 def serialize(self): 1802 r = b"" 1803 r += struct.pack("<B", self.filter_type) 1804 r += ser_uint256(self.stop_hash) 1805 r += ser_uint256(self.prev_header) 1806 r += ser_uint256_vector(self.hashes) 1807 return r 1808 1809 def __repr__(self): 1810 return "msg_cfheaders(filter_type={:#x}, stop_hash={:x})".format( 1811 self.filter_type, self.stop_hash) 1812 1813class msg_getcfcheckpt: 1814 __slots__ = ("filter_type", "stop_hash") 1815 msgtype = b"getcfcheckpt" 1816 1817 def __init__(self, filter_type, stop_hash): 1818 self.filter_type = filter_type 1819 self.stop_hash = stop_hash 1820 1821 def deserialize(self, f): 1822 self.filter_type = struct.unpack("<B", f.read(1))[0] 1823 self.stop_hash = deser_uint256(f) 1824 1825 def serialize(self): 1826 r = b"" 1827 r += struct.pack("<B", self.filter_type) 1828 r += ser_uint256(self.stop_hash) 1829 return r 1830 1831 def __repr__(self): 1832 return "msg_getcfcheckpt(filter_type={:#x}, stop_hash={:x})".format( 1833 self.filter_type, self.stop_hash) 1834 1835class msg_cfcheckpt: 1836 __slots__ = ("filter_type", "stop_hash", "headers") 1837 msgtype = b"cfcheckpt" 1838 1839 def __init__(self, filter_type=None, stop_hash=None, headers=None): 1840 self.filter_type = filter_type 1841 self.stop_hash = stop_hash 1842 self.headers = headers 1843 1844 def deserialize(self, f): 1845 self.filter_type = struct.unpack("<B", f.read(1))[0] 1846 self.stop_hash = deser_uint256(f) 1847 self.headers = deser_uint256_vector(f) 1848 1849 def serialize(self): 1850 r = b"" 1851 r += struct.pack("<B", self.filter_type) 1852 r += ser_uint256(self.stop_hash) 1853 r += ser_uint256_vector(self.headers) 1854 return r 1855 1856 def __repr__(self): 1857 return "msg_cfcheckpt(filter_type={:#x}, stop_hash={:x})".format( 1858 self.filter_type, self.stop_hash) 1859