Update to work with python-bitcoinlib 0.7.0

MemPool.py

@@ -6,7 +6,7 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
-from bitcoin.serialize import uint256_to_shortstr
+from bitcoin.core import CheckTransaction, CheckTransactionError, b2lx
 
 
 class MemPool(object):
@@ -15,14 +15,15 @@ def __init__(self, log):
 		self.log = log
 
 	def add(self, tx):
-		tx.calc_sha256()
-		hash = tx.sha256
-		hashstr = uint256_to_shortstr(hash)
+		hash = tx.GetHash()
+		hashstr = b2lx(hash)
 
 		if hash in self.pool:
 			self.log.write("MemPool.add(%s): already known" % (hashstr,))
 			return False
-		if not tx.is_valid():
+		try:
+			CheckTransaction(tx)
+		except CheckTransactionError:
 			self.log.write("MemPool.add(%s): invalid TX" % (hashstr, ))
 			return False
 

dbck.py

@@ -50,8 +50,10 @@
 	block = CBlock()
 	block.deserialize(f)
 
-	if not block.is_valid():
-		log.write("block %064x failed" % (blkhash,))
+	try:
+		CheckBlock(block)
+	except CheckBlockError:
+		log.write("block %s failed" % (b2lx(blkhash),))
 		failures += 1
 
 	scanned += 1

mkbootstrap.py

@@ -15,7 +15,7 @@
 import struct
 import argparse
 
-from bitcoin.coredefs import NETWORKS
+import bitcoin
 from bitcoin.core import CBlock
 from bitcoin.scripteval import *
 
@@ -31,6 +31,7 @@
 }
 
 MY_NETWORK = 'mainnet'
+bitcoin.SelectParams(MY_NETWORK)
 
 SETTINGS = NET_SETTINGS[MY_NETWORK]
 
@@ -46,9 +47,7 @@
 log = Log.Log()
 
 mempool = MemPool.MemPool(log)
-netmagic = NETWORKS[MY_NETWORK]
-chaindb = ChainDb.ChainDb(SETTINGS, SETTINGS['db'], log, mempool, netmagic,
-			  True)
+chaindb = ChainDb.ChainDb(SETTINGS, SETTINGS['db'], log, mempool, True)
 
 if args.latest:
 	scan_height = chaindb.getheight()
@@ -78,7 +77,7 @@
 
 	ser_block = block.serialize()
 
-	outhdr = netmagic.msg_start
+	outhdr = bitcoin.params.MESSAGE_START
 	outhdr += struct.pack("<i", len(ser_block))
 
 	outf.write(outhdr)

node.py

@@ -27,9 +27,11 @@
 import ChainDb
 import MemPool
 import Log
+import bitcoin
 from bitcoin.core import *
-from bitcoin.serialize import *
+from bitcoin.core.serialize import *
 from bitcoin.messages import *
+from bitcoin.net import *
 
 MY_SUBVERSION = "/pynode:0.0.1/"
 
@@ -61,19 +63,18 @@ def verbose_recvmsg(message):
 
 class NodeConn(Greenlet):
 	def __init__(self, dstaddr, dstport, log, peermgr,
-			 mempool, chaindb, netmagic):
+			 mempool, chaindb):
 		Greenlet.__init__(self)
 		self.log = log
 		self.peermgr = peermgr
 		self.mempool = mempool
 		self.chaindb = chaindb
-		self.netmagic = netmagic
 		self.dstaddr = dstaddr
 		self.dstport = dstport
 		self.sock = gevent.socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 		self.recvbuf = ""
-		self.ver_send = MIN_PROTO_VERSION
-		self.ver_recv = MIN_PROTO_VERSION
+		self.ver_send = PROTO_VERSION
+		self.ver_recv = PROTO_VERSION
 		self.last_sent = 0
 		self.getblocks_ok = True
 		self.last_block_rx = time.time()
@@ -123,27 +124,20 @@ def got_data(self):
 		while True:
 			if len(self.recvbuf) < 4:
 				return
-			if self.recvbuf[:4] != self.netmagic.msg_start:
+			if self.recvbuf[:4] != bitcoin.params.MESSAGE_START:
 				raise ValueError("got garbage %s" % repr(self.recvbuf))
 			# check checksum
 			if len(self.recvbuf) < 4 + 12 + 4 + 4:
 				return
 			command = self.recvbuf[4:4+12].split("\x00", 1)[0]
 			msglen = struct.unpack("<i", self.recvbuf[4+12:4+12+4])[0]
-			checksum = self.recvbuf[4+12+4:4+12+4+4]
 			if len(self.recvbuf) < 4 + 12 + 4 + 4 + msglen:
 				return
-			msg = self.recvbuf[4+12+4+4:4+12+4+4+msglen]
-			th = hashlib.sha256(msg).digest()
-			h = hashlib.sha256(th).digest()
-			if checksum != h[:4]:
-				raise ValueError("got bad checksum %s" % repr(self.recvbuf))
+			msg = self.recvbuf[:4+12+4+4+msglen]
 			self.recvbuf = self.recvbuf[4+12+4+4+msglen:]
 
 			if command in messagemap:
-				f = cStringIO.StringIO(msg)
-				t = messagemap[command](self.ver_recv)
-				t.deserialize(f)
+				t = MsgSerializable.from_bytes(msg)
 				self.got_message(t)
 			else:
 				self.log.write("UNKNOWN COMMAND %s %s" % (command, repr(msg)))
@@ -152,7 +146,7 @@ def send_message(self, message):
 		if verbose_sendmsg(message):
 			self.log.write("send %s" % repr(message))
 
-		tmsg = message_to_str(self.netmagic, message)
+		tmsg = message.to_bytes()
 
 		try:
 			self.sock.sendall(tmsg)
@@ -173,7 +167,7 @@ def send_getblocks(self, timecheck=True):
 			gd = msg_getdata(self.ver_send)
 			inv = CInv()
 			inv.type = 2
-			inv.hash = self.netmagic.block0
+			inv.hash = bitcoin.params.GENESIS_BLOCK.GetHash()
 			gd.inv.append(inv)
 			self.send_message(gd)
 		elif our_height < self.remote_height:
@@ -193,15 +187,11 @@ def got_message(self, message):
 
 		if message.command == "version":
 			self.ver_send = min(PROTO_VERSION, message.nVersion)
-			if self.ver_send < MIN_PROTO_VERSION:
+			if self.ver_send < PROTO_VERSION:
 				self.log.write("Obsolete version %d, closing" % (self.ver_send,))
 				self.handle_close()
 				return
 
-			if (self.ver_send >= NOBLKS_VERSION_START and
-			    self.ver_send <= NOBLKS_VERSION_END):
-				self.getblocks_ok = False
-
 			self.remote_height = message.nStartingHeight
 			self.send_message(msg_verack(self.ver_send))
 			if self.ver_send >= CADDR_TIME_VERSION:
@@ -215,8 +205,7 @@ def got_message(self, message):
 #				self.send_message(msg_mempool())
 
 		elif message.command == "ping":
-			if self.ver_send > BIP0031_VERSION:
-				self.send_message(msg_pong(self.ver_send))
+			self.send_message(msg_pong(self.ver_send))
 
 		elif message.command == "addr":
 			peermgr.new_addrs(message.addrs)
@@ -241,9 +230,9 @@ def got_message(self, message):
 
 		elif message.command == "tx":
 			if self.chaindb.tx_is_orphan(message.tx):
-				self.log.write("MemPool: Ignoring orphan TX %064x" % (message.tx.sha256,))
+				self.log.write("MemPool: Ignoring orphan TX %s" % (b2lx(message.tx.GetHash()),))
 			elif not self.chaindb.tx_signed(message.tx, None, True):
-				self.log.write("MemPool: Ignoring failed-sig TX %064x" % (message.tx.sha256,))
+				self.log.write("MemPool: Ignoring failed-sig TX %s" % (b2lx(message.tx.GetHash()),))
 			else:
 				self.mempool.add(message.tx)
 
@@ -333,14 +322,14 @@ def getdata(self, message):
 	def getblocks(self, message):
 		blkmeta = self.chaindb.locate(message.locator)
 		height = blkmeta.height
-		top_height = self.getheight()
+		top_height = self.chaindb.getheight()
 		end_height = height + 500
 		if end_height > top_height:
 			end_height = top_height
 
 		msg = msg_inv()
 		while height <= end_height:
-			hash = long(self.chaindb.height[str(height)])
+			hash = self.chaindb.getblockhash(height)
 			if hash == message.hashstop:
 				break
 
@@ -359,34 +348,31 @@ def getblocks(self, message):
 	def getheaders(self, message):
 		blkmeta = self.chaindb.locate(message.locator)
 		height = blkmeta.height
-		top_height = self.getheight()
+		top_height = self.chaindb.getheight()
 		end_height = height + 2000
 		if end_height > top_height:
 			end_height = top_height
 
 		msg = msg_headers()
 		while height <= end_height:
-			blkhash = long(self.chaindb.height[str(height)])
+			blkhash = self.chaindb.getblockhash(height)
 			if blkhash == message.hashstop:
 				break
 
-			db_block = self.chaindb.getblock(blkhash)
-			block = copy.copy(db_block)
-			block.vtx = []
+			block = self.chaindb.getblock(blkhash)
 
-			msg.headers.append(block)
+			msg.headers.append(block.get_header())
 
 			height += 1
 
 		self.send_message(msg)
 
 
 class PeerManager(object):
-	def __init__(self, log, mempool, chaindb, netmagic):
+	def __init__(self, log, mempool, chaindb):
 		self.log = log
 		self.mempool = mempool
 		self.chaindb = chaindb
-		self.netmagic = netmagic
 		self.peers = []
 		self.addrs = {}
 		self.tried = {}
@@ -396,7 +382,7 @@ def add(self, host, port):
 			       (host, port))
 		self.tried[host] = True
 		c = NodeConn(host, port, self.log, self, self.mempool,
-			     self.chaindb, self.netmagic)
+			     self.chaindb)
 		self.peers.append(c)
 		return c
 
@@ -467,16 +453,12 @@ def closeall(self):
 
 	log.write("\n\n\n\n")
 
-	if chain not in NETWORKS:
-		log.write("invalid network")
-		sys.exit(1)
-
-	netmagic = NETWORKS[chain]
+	bitcoin.SelectParams(chain)
 
 	mempool = MemPool.MemPool(log)
 	chaindb = ChainDb.ChainDb(settings, settings['db'], log, mempool,
-				  netmagic, False, False)
-	peermgr = PeerManager(log, mempool, chaindb, netmagic)
+				  False, False)
+	peermgr = PeerManager(log, mempool, chaindb)
 
 	if 'loadblock' in settings:
 		chaindb.loadfile(settings['loadblock'])

q_avg_size.py

@@ -14,7 +14,7 @@
 import cStringIO
 import struct
 
-from bitcoin.coredefs import NETWORKS
+import bitcoin
 from bitcoin.core import CBlock
 from bitcoin.scripteval import *
 
@@ -30,14 +30,13 @@
 }
 
 MY_NETWORK = 'mainnet'
+bitcoin.SelectParams(MY_NETWORK)
 
 SETTINGS = NET_SETTINGS[MY_NETWORK]
 
 log = Log.Log(SETTINGS['log'])
 mempool = MemPool.MemPool(log)
-netmagic = NETWORKS[MY_NETWORK]
-chaindb = ChainDb.ChainDb(SETTINGS, SETTINGS['db'], log, mempool, netmagic,
-			  True)
+chaindb = ChainDb.ChainDb(SETTINGS, SETTINGS['db'], log, mempool, True)
 
 scanned = 0
 failures = 0

rpc.py

@@ -15,8 +15,8 @@
 import itertools
 
 import ChainDb
-import bitcoin.coredefs
-from bitcoin.serialize import uint256_from_compact
+import bitcoin.core
+from bitcoin.core.serialize import uint256_from_compact
 
 VALID_RPCS = {
 	"getblockcount",
@@ -52,24 +52,22 @@ def bufreverse(in_buf):
 	return ''.join(out_words)
 
 def blockToJSON(block, blkmeta, cur_height):
-	block.calc_sha256()
 	res = {}
 
-	res['hash'] = "%064x" % (block.sha256,)
+	res['hash'] = b2lx(block.GetHash())
 	res['confirmations'] = cur_height - blkmeta.height + 1
 	res['size'] = len(block.serialize())
 	res['height'] = blkmeta.height
 	res['version'] = block.nVersion
-	res['merkleroot'] = "%064x" % (block.hashMerkleRoot,)
+	res['merkleroot'] = b2lx(block.hashMerkleRoot)
 	res['time'] = block.nTime
 	res['nonce'] = block.nNonce
 	res['bits'] = "%x" % (block.nBits,)
-	res['previousblockhash'] = "%064x" % (block.hashPrevBlock,)
+	res['previousblockhash'] = b2lx(block.hashPrevBlock)
 
 	txs = []
 	for tx in block.vtx:
-		tx.calc_sha256()
-		txs.append("%064x" % (tx.sha256,))
+		txs.append("%s" % (b2lx(tx.GetHash()),))
 
 	res['tx'] = txs
 
@@ -139,16 +137,16 @@ def getblockhash(self, params):
 		heightidx = ChainDb.HeightIdx()
 		heightidx.deserialize(self.chaindb.height[str(index)])
 
-		return ("%064x" % (heightidx.blocks[0],), None)
+		return (b2lx(heightidx.blocks[0]), None)
 
 	def getconnectioncount(self, params):
 		return (len(self.peermgr.peers), None)
 
 	def getinfo(self, params):
 		d = {}
-		d['protocolversion'] = bitcoin.coredefs.PROTO_VERSION
+		d['protocolversion'] = bitcoin.core.PROTO_VERSION
 		d['blocks'] = self.chaindb.getheight()
-		if self.chaindb.netmagic.block0 == 0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26fL:
+		if bitcoin.params.GENESIS_BLOCK.GetHash() == bitcoin.core.lx('000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f'):
 			d['testnet'] = False
 		else:
 			d['testnet'] = True
@@ -157,7 +155,7 @@ def getinfo(self, params):
 	def getrawmempool(self, params):
 		l = []
 		for k in self.mempool.pool.iterkeys():
-			l.append("%064x" % (k,))
+			l.append(b2lx(k))
 		return (l, None)
 
 	def getrawtransaction(self, params):
@@ -195,7 +193,7 @@ def getwork_new(self):
 		res = {}
 
 		target = uint256_from_compact(block.nBits)
-		res['target'] = "%064x" % (target,)
+		res['target'] = b2lx(target)
 
 		data = block.serialize()
 		data = data[:80]