Update qa from Bitcoin Core 0.13.2
This commit is contained in:
lateminer
@@ -28,7 +28,7 @@ import asyncore
|
||||
import time
|
||||
import sys
|
||||
import random
|
||||
from binascii import hexlify, unhexlify
|
||||
from .util import hex_str_to_bytes, bytes_to_hex_str
|
||||
from io import BytesIO
|
||||
from codecs import encode
|
||||
import hashlib
|
||||
@@ -36,9 +36,10 @@ from threading import RLock
|
||||
from threading import Thread
|
||||
import logging
|
||||
import copy
|
||||
from test_framework.siphash import siphash256
|
||||
|
||||
BIP0031_VERSION = 60000
|
||||
MY_VERSION = 60001 # past bip-31 for ping/pong
|
||||
MY_VERSION = 70014 # past bip-31 for ping/pong
|
||||
MY_SUBVERSION = b"/python-mininode-tester:0.0.3/"
|
||||
|
||||
MAX_INV_SZ = 50000
|
||||
@@ -46,8 +47,12 @@ MAX_BLOCK_SIZE = 1000000
|
||||
|
||||
COIN = 100000000 # 1 btc in satoshis
|
||||
|
||||
NODE_NETWORK = (1 << 0)
|
||||
NODE_GETUTXO = (1 << 1)
|
||||
NODE_BLOOM = (1 << 2)
|
||||
|
||||
# Keep our own socket map for asyncore, so that we can track disconnects
|
||||
# ourselves (to workaround an issue with closing an asyncore socket when
|
||||
# ourselves (to workaround an issue with closing an asyncore socket when
|
||||
# using select)
|
||||
mininode_socket_map = dict()
|
||||
|
||||
@@ -63,12 +68,25 @@ mininode_lock = RLock()
|
||||
def sha256(s):
|
||||
return hashlib.new('sha256', s).digest()
|
||||
|
||||
def ripemd160(s):
|
||||
return hashlib.new('ripemd160', s).digest()
|
||||
|
||||
def hash256(s):
|
||||
return sha256(sha256(s))
|
||||
|
||||
def ser_compact_size(l):
|
||||
r = b""
|
||||
if l < 253:
|
||||
r = struct.pack("B", l)
|
||||
elif l < 0x10000:
|
||||
r = struct.pack("<BH", 253, l)
|
||||
elif l < 0x100000000:
|
||||
r = struct.pack("<BI", 254, l)
|
||||
else:
|
||||
r = struct.pack("<BQ", 255, l)
|
||||
return r
|
||||
|
||||
def deser_string(f):
|
||||
def deser_compact_size(f):
|
||||
nit = struct.unpack("<B", f.read(1))[0]
|
||||
if nit == 253:
|
||||
nit = struct.unpack("<H", f.read(2))[0]
|
||||
@@ -76,16 +94,14 @@ def deser_string(f):
|
||||
nit = struct.unpack("<I", f.read(4))[0]
|
||||
elif nit == 255:
|
||||
nit = struct.unpack("<Q", f.read(8))[0]
|
||||
return nit
|
||||
|
||||
def deser_string(f):
|
||||
nit = deser_compact_size(f)
|
||||
return f.read(nit)
|
||||
|
||||
def ser_string(s):
|
||||
if len(s) < 253:
|
||||
return struct.pack("B", len(s)) + s
|
||||
elif len(s) < 0x10000:
|
||||
return struct.pack("<BH", 253, len(s)) + s
|
||||
elif len(s) < 0x100000000:
|
||||
return struct.pack("<BI", 254, len(s)) + s
|
||||
return struct.pack("<BQ", 255, len(s)) + s
|
||||
return ser_compact_size(len(s)) + s
|
||||
|
||||
def deser_uint256(f):
|
||||
r = 0
|
||||
@@ -118,13 +134,7 @@ def uint256_from_compact(c):
|
||||
|
||||
|
||||
def deser_vector(f, c):
|
||||
nit = struct.unpack("<B", f.read(1))[0]
|
||||
if nit == 253:
|
||||
nit = struct.unpack("<H", f.read(2))[0]
|
||||
elif nit == 254:
|
||||
nit = struct.unpack("<I", f.read(4))[0]
|
||||
elif nit == 255:
|
||||
nit = struct.unpack("<Q", f.read(8))[0]
|
||||
nit = deser_compact_size(f)
|
||||
r = []
|
||||
for i in range(nit):
|
||||
t = c()
|
||||
@@ -133,29 +143,20 @@ def deser_vector(f, c):
|
||||
return r
|
||||
|
||||
|
||||
def ser_vector(l):
|
||||
r = b""
|
||||
if len(l) < 253:
|
||||
r = struct.pack("B", len(l))
|
||||
elif len(l) < 0x10000:
|
||||
r = struct.pack("<BH", 253, len(l))
|
||||
elif len(l) < 0x100000000:
|
||||
r = struct.pack("<BI", 254, len(l))
|
||||
else:
|
||||
r = struct.pack("<BQ", 255, len(l))
|
||||
# ser_function_name: Allow for an alternate serialization function on the
|
||||
# entries in the vector.
|
||||
def ser_vector(l, ser_function_name=None):
|
||||
r = ser_compact_size(len(l))
|
||||
for i in l:
|
||||
r += i.serialize()
|
||||
if ser_function_name:
|
||||
r += getattr(i, ser_function_name)()
|
||||
else:
|
||||
r += i.serialize()
|
||||
return r
|
||||
|
||||
|
||||
def deser_uint256_vector(f):
|
||||
nit = struct.unpack("<B", f.read(1))[0]
|
||||
if nit == 253:
|
||||
nit = struct.unpack("<H", f.read(2))[0]
|
||||
elif nit == 254:
|
||||
nit = struct.unpack("<I", f.read(4))[0]
|
||||
elif nit == 255:
|
||||
nit = struct.unpack("<Q", f.read(8))[0]
|
||||
nit = deser_compact_size(f)
|
||||
r = []
|
||||
for i in range(nit):
|
||||
t = deser_uint256(f)
|
||||
@@ -164,28 +165,14 @@ def deser_uint256_vector(f):
|
||||
|
||||
|
||||
def ser_uint256_vector(l):
|
||||
r = b""
|
||||
if len(l) < 253:
|
||||
r = struct.pack("B", len(l))
|
||||
elif len(l) < 0x10000:
|
||||
r = struct.pack("<BH", 253, len(l))
|
||||
elif len(l) < 0x100000000:
|
||||
r = struct.pack("<BI", 254, len(l))
|
||||
else:
|
||||
r = struct.pack("<BQ", 255, len(l))
|
||||
r = ser_compact_size(len(l))
|
||||
for i in l:
|
||||
r += ser_uint256(i)
|
||||
return r
|
||||
|
||||
|
||||
def deser_string_vector(f):
|
||||
nit = struct.unpack("<B", f.read(1))[0]
|
||||
if nit == 253:
|
||||
nit = struct.unpack("<H", f.read(2))[0]
|
||||
elif nit == 254:
|
||||
nit = struct.unpack("<I", f.read(4))[0]
|
||||
elif nit == 255:
|
||||
nit = struct.unpack("<Q", f.read(8))[0]
|
||||
nit = deser_compact_size(f)
|
||||
r = []
|
||||
for i in range(nit):
|
||||
t = deser_string(f)
|
||||
@@ -194,28 +181,14 @@ def deser_string_vector(f):
|
||||
|
||||
|
||||
def ser_string_vector(l):
|
||||
r = b""
|
||||
if len(l) < 253:
|
||||
r = struct.pack("B", len(l))
|
||||
elif len(l) < 0x10000:
|
||||
r = struct.pack("<BH", 253, len(l))
|
||||
elif len(l) < 0x100000000:
|
||||
r = struct.pack("<BI", 254, len(l))
|
||||
else:
|
||||
r = struct.pack("<BQ", 255, len(l))
|
||||
r = ser_compact_size(len(l))
|
||||
for sv in l:
|
||||
r += ser_string(sv)
|
||||
return r
|
||||
|
||||
|
||||
def deser_int_vector(f):
|
||||
nit = struct.unpack("<B", f.read(1))[0]
|
||||
if nit == 253:
|
||||
nit = struct.unpack("<H", f.read(2))[0]
|
||||
elif nit == 254:
|
||||
nit = struct.unpack("<I", f.read(4))[0]
|
||||
elif nit == 255:
|
||||
nit = struct.unpack("<Q", f.read(8))[0]
|
||||
nit = deser_compact_size(f)
|
||||
r = []
|
||||
for i in range(nit):
|
||||
t = struct.unpack("<i", f.read(4))[0]
|
||||
@@ -224,27 +197,19 @@ def deser_int_vector(f):
|
||||
|
||||
|
||||
def ser_int_vector(l):
|
||||
r = b""
|
||||
if len(l) < 253:
|
||||
r = struct.pack("B", len(l))
|
||||
elif len(l) < 0x10000:
|
||||
r = struct.pack("<BH", 253, len(l))
|
||||
elif len(l) < 0x100000000:
|
||||
r = struct.pack("<BI", 254, len(l))
|
||||
else:
|
||||
r = struct.pack("<BQ", 255, len(l))
|
||||
r = ser_compact_size(len(l))
|
||||
for i in l:
|
||||
r += struct.pack("<i", i)
|
||||
return r
|
||||
|
||||
# Deserialize from a hex string representation (eg from RPC)
|
||||
def FromHex(obj, hex_string):
|
||||
obj.deserialize(BytesIO(unhexlify(hex_string.encode('ascii'))))
|
||||
obj.deserialize(BytesIO(hex_str_to_bytes(hex_string)))
|
||||
return obj
|
||||
|
||||
# Convert a binary-serializable object to hex (eg for submission via RPC)
|
||||
def ToHex(obj):
|
||||
return hexlify(obj.serialize()).decode('ascii')
|
||||
return bytes_to_hex_str(obj.serialize())
|
||||
|
||||
# Objects that map to bitcoind objects, which can be serialized/deserialized
|
||||
|
||||
@@ -274,31 +239,6 @@ class CAddress(object):
|
||||
self.ip, self.port)
|
||||
|
||||
|
||||
class CInv(object):
|
||||
typemap = {
|
||||
0: "Error",
|
||||
1: "TX",
|
||||
2: "Block"}
|
||||
|
||||
def __init__(self, t=0, h=0):
|
||||
self.type = t
|
||||
self.hash = h
|
||||
|
||||
def deserialize(self, f):
|
||||
self.type = struct.unpack("<i", f.read(4))[0]
|
||||
self.hash = deser_uint256(f)
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += struct.pack("<i", self.type)
|
||||
r += ser_uint256(self.hash)
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
return "CInv(type=%s hash=%064x)" \
|
||||
% (self.typemap[self.type], self.hash)
|
||||
|
||||
|
||||
class CBlockLocator(object):
|
||||
def __init__(self):
|
||||
self.nVersion = MY_VERSION
|
||||
@@ -362,7 +302,7 @@ class CTxIn(object):
|
||||
|
||||
def __repr__(self):
|
||||
return "CTxIn(prevout=%s scriptSig=%s nSequence=%i)" \
|
||||
% (repr(self.prevout), hexlify(self.scriptSig),
|
||||
% (repr(self.prevout), bytes_to_hex_str(self.scriptSig),
|
||||
self.nSequence)
|
||||
|
||||
|
||||
@@ -384,7 +324,7 @@ class CTxOut(object):
|
||||
def __repr__(self):
|
||||
return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" \
|
||||
% (self.nValue // COIN, self.nValue % COIN,
|
||||
hexlify(self.scriptPubKey))
|
||||
bytes_to_hex_str(self.scriptPubKey))
|
||||
|
||||
|
||||
class CTransaction(object):
|
||||
@@ -401,8 +341,8 @@ class CTransaction(object):
|
||||
self.vin = copy.deepcopy(tx.vin)
|
||||
self.vout = copy.deepcopy(tx.vout)
|
||||
self.nLockTime = tx.nLockTime
|
||||
self.sha256 = None
|
||||
self.hash = None
|
||||
self.sha256 = tx.sha256
|
||||
self.hash = tx.hash
|
||||
|
||||
def deserialize(self, f):
|
||||
self.nVersion = struct.unpack("<i", f.read(4))[0]
|
||||
@@ -420,13 +360,15 @@ class CTransaction(object):
|
||||
r += struct.pack("<I", self.nLockTime)
|
||||
return r
|
||||
|
||||
# Recalculate the txid
|
||||
def rehash(self):
|
||||
self.sha256 = None
|
||||
self.calc_sha256()
|
||||
|
||||
# self.sha256 and self.hash -- those are expected to be the txid.
|
||||
def calc_sha256(self):
|
||||
if self.sha256 is None:
|
||||
self.sha256 = uint256_from_str(hash256(self.serialize()))
|
||||
self.sha256 = uint256_from_str(hash256(self.serialize))
|
||||
self.hash = encode(hash256(self.serialize())[::-1], 'hex_codec').decode('ascii')
|
||||
|
||||
def is_valid(self):
|
||||
@@ -524,11 +466,8 @@ class CBlock(CBlockHeader):
|
||||
r += ser_vector(self.vtx)
|
||||
return r
|
||||
|
||||
def calc_merkle_root(self):
|
||||
hashes = []
|
||||
for tx in self.vtx:
|
||||
tx.calc_sha256()
|
||||
hashes.append(ser_uint256(tx.sha256))
|
||||
# Calculate the merkle root given a vector of transaction hashes
|
||||
def get_merkle_root(self, hashes):
|
||||
while len(hashes) > 1:
|
||||
newhashes = []
|
||||
for i in range(0, len(hashes), 2):
|
||||
@@ -537,6 +476,13 @@ class CBlock(CBlockHeader):
|
||||
hashes = newhashes
|
||||
return uint256_from_str(hashes[0])
|
||||
|
||||
def calc_merkle_root(self):
|
||||
hashes = []
|
||||
for tx in self.vtx:
|
||||
tx.calc_sha256()
|
||||
hashes.append(ser_uint256(tx.sha256))
|
||||
return self.get_merkle_root(hashes)
|
||||
|
||||
def is_valid(self):
|
||||
self.calc_sha256()
|
||||
target = uint256_from_compact(self.nBits)
|
||||
@@ -556,7 +502,6 @@ class CBlock(CBlockHeader):
|
||||
self.nNonce += 1
|
||||
self.rehash()
|
||||
|
||||
|
||||
def __repr__(self):
|
||||
return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%s)" \
|
||||
% (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
|
||||
@@ -638,6 +583,182 @@ class CAlert(object):
|
||||
% (len(self.vchMsg), len(self.vchSig))
|
||||
|
||||
|
||||
class PrefilledTransaction(object):
|
||||
def __init__(self, index=0, tx = None):
|
||||
self.index = index
|
||||
self.tx = tx
|
||||
|
||||
def deserialize(self, f):
|
||||
self.index = deser_compact_size(f)
|
||||
self.tx = CTransaction()
|
||||
self.tx.deserialize(f)
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += ser_compact_size(self.index)
|
||||
r += self.tx.serialize()
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
return "PrefilledTransaction(index=%d, tx=%s)" % (self.index, repr(self.tx))
|
||||
|
||||
# This is what we send on the wire, in a cmpctblock message.
|
||||
class P2PHeaderAndShortIDs(object):
|
||||
def __init__(self):
|
||||
self.header = CBlockHeader()
|
||||
self.nonce = 0
|
||||
self.shortids_length = 0
|
||||
self.shortids = []
|
||||
self.prefilled_txn_length = 0
|
||||
self.prefilled_txn = []
|
||||
|
||||
def deserialize(self, f):
|
||||
self.header.deserialize(f)
|
||||
self.nonce = struct.unpack("<Q", f.read(8))[0]
|
||||
self.shortids_length = deser_compact_size(f)
|
||||
for i in range(self.shortids_length):
|
||||
# shortids are defined to be 6 bytes in the spec, so append
|
||||
# two zero bytes and read it in as an 8-byte number
|
||||
self.shortids.append(struct.unpack("<Q", f.read(6) + b'\x00\x00')[0])
|
||||
self.prefilled_txn = deser_vector(f, PrefilledTransaction)
|
||||
self.prefilled_txn_length = len(self.prefilled_txn)
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += self.header.serialize()
|
||||
r += struct.pack("<Q", self.nonce)
|
||||
r += ser_compact_size(self.shortids_length)
|
||||
for x in self.shortids:
|
||||
# We only want the first 6 bytes
|
||||
r += struct.pack("<Q", x)[0:6]
|
||||
r += ser_vector(self.prefilled_txn)
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
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))
|
||||
|
||||
# Calculate the BIP 152-compact blocks shortid for a given transaction hash
|
||||
def calculate_shortid(k0, k1, tx_hash):
|
||||
expected_shortid = siphash256(k0, k1, tx_hash)
|
||||
expected_shortid &= 0x0000ffffffffffff
|
||||
return expected_shortid
|
||||
|
||||
# This version gets rid of the array lengths, and reinterprets the differential
|
||||
# encoding into indices that can be used for lookup.
|
||||
class HeaderAndShortIDs(object):
|
||||
def __init__(self, p2pheaders_and_shortids = None):
|
||||
self.header = CBlockHeader()
|
||||
self.nonce = 0
|
||||
self.shortids = []
|
||||
self.prefilled_txn = []
|
||||
|
||||
if p2pheaders_and_shortids != None:
|
||||
self.header = p2pheaders_and_shortids.header
|
||||
self.nonce = p2pheaders_and_shortids.nonce
|
||||
self.shortids = p2pheaders_and_shortids.shortids
|
||||
last_index = -1
|
||||
for x in p2pheaders_and_shortids.prefilled_txn:
|
||||
self.prefilled_txn.append(PrefilledTransaction(x.index + last_index + 1, x.tx))
|
||||
last_index = self.prefilled_txn[-1].index
|
||||
|
||||
def to_p2p(self):
|
||||
ret = P2PHeaderAndShortIDs()
|
||||
ret.header = self.header
|
||||
ret.nonce = self.nonce
|
||||
ret.shortids_length = len(self.shortids)
|
||||
ret.shortids = self.shortids
|
||||
ret.prefilled_txn_length = len(self.prefilled_txn)
|
||||
ret.prefilled_txn = []
|
||||
last_index = -1
|
||||
for x in self.prefilled_txn:
|
||||
ret.prefilled_txn.append(PrefilledTransaction(x.index - last_index - 1, x.tx))
|
||||
last_index = x.index
|
||||
return ret
|
||||
|
||||
def get_siphash_keys(self):
|
||||
header_nonce = self.header.serialize()
|
||||
header_nonce += struct.pack("<Q", self.nonce)
|
||||
hash_header_nonce_as_str = sha256(header_nonce)
|
||||
key0 = struct.unpack("<Q", hash_header_nonce_as_str[0:8])[0]
|
||||
key1 = struct.unpack("<Q", hash_header_nonce_as_str[8:16])[0]
|
||||
return [ key0, key1 ]
|
||||
|
||||
# Version 2 compact blocks use wtxid in shortids (rather than txid)
|
||||
def initialize_from_block(self, block, nonce=0, prefill_list = [0]):
|
||||
self.header = CBlockHeader(block)
|
||||
self.nonce = nonce
|
||||
self.prefilled_txn = [ PrefilledTransaction(i, block.vtx[i]) for i in prefill_list ]
|
||||
self.shortids = []
|
||||
[k0, k1] = self.get_siphash_keys()
|
||||
for i in range(len(block.vtx)):
|
||||
if i not in prefill_list:
|
||||
tx_hash = block.vtx[i].sha256
|
||||
self.shortids.append(calculate_shortid(k0, k1, tx_hash))
|
||||
|
||||
def __repr__(self):
|
||||
return "HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s" % (repr(self.header), self.nonce, repr(self.shortids), repr(self.prefilled_txn))
|
||||
|
||||
|
||||
class BlockTransactionsRequest(object):
|
||||
|
||||
def __init__(self, blockhash=0, indexes = None):
|
||||
self.blockhash = blockhash
|
||||
self.indexes = indexes if indexes != None else []
|
||||
|
||||
def deserialize(self, f):
|
||||
self.blockhash = deser_uint256(f)
|
||||
indexes_length = deser_compact_size(f)
|
||||
for i in range(indexes_length):
|
||||
self.indexes.append(deser_compact_size(f))
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += ser_uint256(self.blockhash)
|
||||
r += ser_compact_size(len(self.indexes))
|
||||
for x in self.indexes:
|
||||
r += ser_compact_size(x)
|
||||
return r
|
||||
|
||||
# helper to set the differentially encoded indexes from absolute ones
|
||||
def from_absolute(self, absolute_indexes):
|
||||
self.indexes = []
|
||||
last_index = -1
|
||||
for x in absolute_indexes:
|
||||
self.indexes.append(x-last_index-1)
|
||||
last_index = x
|
||||
|
||||
def to_absolute(self):
|
||||
absolute_indexes = []
|
||||
last_index = -1
|
||||
for x in self.indexes:
|
||||
absolute_indexes.append(x+last_index+1)
|
||||
last_index = absolute_indexes[-1]
|
||||
return absolute_indexes
|
||||
|
||||
def __repr__(self):
|
||||
return "BlockTransactionsRequest(hash=%064x indexes=%s)" % (self.blockhash, repr(self.indexes))
|
||||
|
||||
|
||||
class BlockTransactions(object):
|
||||
|
||||
def __init__(self, blockhash=0, transactions = None):
|
||||
self.blockhash = blockhash
|
||||
self.transactions = transactions if transactions != None else []
|
||||
|
||||
def deserialize(self, f):
|
||||
self.blockhash = deser_uint256(f)
|
||||
self.transactions = deser_vector(f, CTransaction)
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += ser_uint256(self.blockhash)
|
||||
r += ser_vector(self.transactions)
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
return "BlockTransactions(hash=%064x transactions=%s)" % (self.blockhash, repr(self.transactions))
|
||||
|
||||
|
||||
# Objects that correspond to messages on the wire
|
||||
class msg_version(object):
|
||||
command = b"version"
|
||||
@@ -850,6 +971,7 @@ class msg_generic(object):
|
||||
def __repr__(self):
|
||||
return "msg_generic()"
|
||||
|
||||
|
||||
class msg_getaddr(object):
|
||||
command = b"getaddr"
|
||||
|
||||
@@ -1030,7 +1152,7 @@ class msg_reject(object):
|
||||
% (self.message, self.code, self.reason, self.data)
|
||||
|
||||
# Helper function
|
||||
def wait_until(predicate, attempts=float('inf'), timeout=float('inf')):
|
||||
def wait_until(predicate, *, attempts=float('inf'), timeout=float('inf')):
|
||||
attempt = 0
|
||||
elapsed = 0
|
||||
|
||||
@@ -1045,22 +1167,95 @@ def wait_until(predicate, attempts=float('inf'), timeout=float('inf')):
|
||||
return False
|
||||
|
||||
class msg_feefilter(object):
|
||||
command = "feefilter"
|
||||
command = b"feefilter"
|
||||
|
||||
def __init__(self, feerate=0L):
|
||||
def __init__(self, feerate=0):
|
||||
self.feerate = feerate
|
||||
|
||||
def deserialize(self, f):
|
||||
self.feerate = struct.unpack("<Q", f.read(8))[0]
|
||||
|
||||
def serialize(self):
|
||||
r = ""
|
||||
r = b""
|
||||
r += struct.pack("<Q", self.feerate)
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
return "msg_feefilter(feerate=%08x)" % self.feerate
|
||||
|
||||
class msg_sendcmpct(object):
|
||||
command = b"sendcmpct"
|
||||
|
||||
def __init__(self):
|
||||
self.announce = False
|
||||
self.version = 1
|
||||
|
||||
def deserialize(self, f):
|
||||
self.announce = struct.unpack("<?", f.read(1))[0]
|
||||
self.version = struct.unpack("<Q", f.read(8))[0]
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += struct.pack("<?", self.announce)
|
||||
r += struct.pack("<Q", self.version)
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
return "msg_sendcmpct(announce=%s, version=%lu)" % (self.announce, self.version)
|
||||
|
||||
class msg_cmpctblock(object):
|
||||
command = b"cmpctblock"
|
||||
|
||||
def __init__(self, header_and_shortids = None):
|
||||
self.header_and_shortids = header_and_shortids
|
||||
|
||||
def deserialize(self, f):
|
||||
self.header_and_shortids = P2PHeaderAndShortIDs()
|
||||
self.header_and_shortids.deserialize(f)
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += self.header_and_shortids.serialize()
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
return "msg_cmpctblock(HeaderAndShortIDs=%s)" % repr(self.header_and_shortids)
|
||||
|
||||
class msg_getblocktxn(object):
|
||||
command = b"getblocktxn"
|
||||
|
||||
def __init__(self):
|
||||
self.block_txn_request = None
|
||||
|
||||
def deserialize(self, f):
|
||||
self.block_txn_request = BlockTransactionsRequest()
|
||||
self.block_txn_request.deserialize(f)
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += self.block_txn_request.serialize()
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
return "msg_getblocktxn(block_txn_request=%s)" % (repr(self.block_txn_request))
|
||||
|
||||
class msg_blocktxn(object):
|
||||
command = b"blocktxn"
|
||||
|
||||
def __init__(self):
|
||||
self.block_transactions = BlockTransactions()
|
||||
|
||||
def deserialize(self, f):
|
||||
self.block_transactions.deserialize(f)
|
||||
|
||||
def serialize(self):
|
||||
r = b""
|
||||
r += self.block_transactions.serialize()
|
||||
return r
|
||||
|
||||
def __repr__(self):
|
||||
return "msg_blocktxn(block_transactions=%s)" % (repr(self.block_transactions))
|
||||
|
||||
# This is what a callback should look like for NodeConn
|
||||
# Reimplement the on_* functions to provide handling for events
|
||||
class NodeConnCB(object):
|
||||
@@ -1070,6 +1265,8 @@ class NodeConnCB(object):
|
||||
# tests; it causes message delivery to sleep for the specified time
|
||||
# before acquiring the global lock and delivering the next message.
|
||||
self.deliver_sleep_time = None
|
||||
# Remember the services our peer has advertised
|
||||
self.peer_services = None
|
||||
|
||||
def set_deliver_sleep_time(self, value):
|
||||
with mininode_lock:
|
||||
@@ -1107,6 +1304,7 @@ class NodeConnCB(object):
|
||||
conn.ver_send = min(MY_VERSION, message.nVersion)
|
||||
if message.nVersion < 209:
|
||||
conn.ver_recv = conn.ver_send
|
||||
conn.nServices = message.nServices
|
||||
|
||||
def on_verack(self, conn, message):
|
||||
conn.ver_recv = conn.ver_send
|
||||
@@ -1138,6 +1336,10 @@ class NodeConnCB(object):
|
||||
def on_pong(self, conn, message): pass
|
||||
def on_feefilter(self, conn, message): pass
|
||||
def on_sendheaders(self, conn, message): pass
|
||||
def on_sendcmpct(self, conn, message): pass
|
||||
def on_cmpctblock(self, conn, message): pass
|
||||
def on_getblocktxn(self, conn, message): pass
|
||||
def on_blocktxn(self, conn, message): pass
|
||||
|
||||
# More useful callbacks and functions for NodeConnCB's which have a single NodeConn
|
||||
class SingleNodeConnCB(NodeConnCB):
|
||||
@@ -1154,6 +1356,10 @@ class SingleNodeConnCB(NodeConnCB):
|
||||
def send_message(self, message):
|
||||
self.connection.send_message(message)
|
||||
|
||||
def send_and_ping(self, message):
|
||||
self.send_message(message)
|
||||
self.sync_with_ping()
|
||||
|
||||
def on_pong(self, conn, message):
|
||||
self.last_pong = message
|
||||
|
||||
@@ -1187,15 +1393,19 @@ class NodeConn(asyncore.dispatcher):
|
||||
b"reject": msg_reject,
|
||||
b"mempool": msg_mempool,
|
||||
b"feefilter": msg_feefilter,
|
||||
b"sendheaders": msg_sendheaders
|
||||
b"sendheaders": msg_sendheaders,
|
||||
b"sendcmpct": msg_sendcmpct,
|
||||
b"cmpctblock": msg_cmpctblock,
|
||||
b"getblocktxn": msg_getblocktxn,
|
||||
b"blocktxn": msg_blocktxn
|
||||
}
|
||||
MAGIC_BYTES = {
|
||||
"mainnet": b"\xf9\xbe\xb4\xd9", # mainnet
|
||||
"testnet3": b"\x0b\x11\x09\x07", # testnet3
|
||||
"regtest": b"\xfa\xbf\xb5\xda" # regtest
|
||||
"regtest": b"\xfa\xbf\xb5\xda", # regtest
|
||||
}
|
||||
|
||||
def __init__(self, dstaddr, dstport, rpc, callback, net="regtest", services=1):
|
||||
def __init__(self, dstaddr, dstport, rpc, callback, net="regtest", services=NODE_NETWORK):
|
||||
asyncore.dispatcher.__init__(self, map=mininode_socket_map)
|
||||
self.log = logging.getLogger("NodeConn(%s:%d)" % (dstaddr, dstport))
|
||||
self.dstaddr = dstaddr
|
||||
@@ -1210,6 +1420,7 @@ class NodeConn(asyncore.dispatcher):
|
||||
self.network = net
|
||||
self.cb = callback
|
||||
self.disconnect = False
|
||||
self.nServices = 0
|
||||
|
||||
# stuff version msg into sendbuf
|
||||
vt = msg_version()
|
||||
@@ -1319,7 +1530,7 @@ class NodeConn(asyncore.dispatcher):
|
||||
|
||||
def send_message(self, message, pushbuf=False):
|
||||
if self.state != "connected" and not pushbuf:
|
||||
return
|
||||
raise IOError('Not connected, no pushbuf')
|
||||
self.show_debug_msg("Send %s" % repr(message))
|
||||
command = message.command
|
||||
data = message.serialize()
|
||||
|
||||
Reference in New Issue
Block a user