#! / USR / бен / окр питон
импорт структура
импорт hashlib

Защиту uint256_deser (ы):
	г = 0L
	для г в xrange (8):
		т = struct.unpack ("<я", С [я * 4: я * 4 + 4]) [0]
		г + = т << (Я * 32)
	возвращение г

Защиту uint256_ser (и):
	Rs = ""
	для г в xrange (8):
		RS + = struct.pack ("<я", у & 0xFFFFFFFFL)
		U >>= 32
	вернуться RS

Защиту uint256_from_compact (с):
	= число-байт (с >> 24) & 0xFF
	v = (с & 0xFFFFFFL) << (8 * (- 3 число-байт))
	возврат v

Защиту get_difficulty (с):
	вернуться поплавка (uint256_from_compact (0x1D00FFFF) * 1000 // uint256_from_compact (с)) / 1000.

Класс CBlock:
	Защита десериализации (я, s):
		self.nVersion = struct.unpack ("<я", С [0: 4]) [0]
		self.hashPrevBlock = uint256_deser (с [4:36])
		self.hashMerkleRoot = uint256_deser (ы [36:68])
		self.nTime = struct.unpack ("<я", С [68:72]) [0]
		self.nBits = struct.unpack ("<я", С [72:76]) [0]
		self.nNonce = struct.unpack ("<я", С [76:80]) [0]
		h1 = hashlib.sha256 (с [0:80]). (переваривают)
		self.hash = uint256_deser (hashlib.sha256 (h1) .digest ())
		если self.hash > uint256_from_compact (self.nBits):
			поднять ValueError ("плохой хэш в% с" % Магнезия (сам))
		self.next = []
		self.blocknum = -1
	Защиту __repr __ (Я):
		вернуть "CBlock {вер =% 08x л.с. =% 064x гм =% 064x нт =% 08x пь =% 08x пп =% 08x ч =% 064x, п =% я}" % (Self.nVersion, self.hashPrevBlock, self.hashMerkleRoot, self.nTime, self.nBits, self.nNonce, self.hash, self.blocknum)

Защиту get_chain_len (BLK):
	г = 1
	в то время как Len (blk.next) == 1:
		BLK = blk.next [0]
		г + 1 =
	если Len (blk.next) > 1:
		bestchainlen = 0
		для nextblk в blk.next:
			chainlen = get_chain_len (nextblk)
			если chainlen > bestchainlen:
				bestchainlen = chainlen
		г + = bestchainlen
	возвращение г


Защиту readblocks (имя файла):
	е = открытое (имя файла, "Р.Б.")
	блоки = []
	idxmap = {}
	в то время как True:
		пытаться:
			магии = f.read (4)
			если магия! = "\ Xf9 \ XBE \ XB4 \ xd9":
				ломать
			blklen = struct.unpack ("<я", F.read (4)) [0]
			если blklen < 80:
				ломать
			blkdata = f.read (blklen)
			если Len (blkdata) = blklen:
				ломать
		Кроме:
			ломать
		BLK = CBlock ()
		blk.deserialize (blkdata)
		blocks.append (BLK)
		idxmap [blk.hash] = BLK
		если blk.hashPrevBlock:
			prevblk = idxmap [blk.hashPrevBlock]
			blk.prev = prevblk
			prevblk.next.append (BLK)
	f.close ()
	rootblk = блоки [0]
	дель блоки
	дель idxmap
	BLK = rootblk
	curblkidx = 0
	в то время как True:
		blk.blocknum = curblkidx
		если Len (blk.next) == 0:
			не blk.next = None
			ломать
		если Len (blk.next) > 1:
			не bestnextblk = None
			bestchainlen = 0
			для nextblk в blk.next:
				chainlen = get_chain_len (nextblk)
				если chainlen > bestchainlen:
					bestchainlen = chainlen
					bestnextblk = nextblk
				Элиф chainlen == bestchainlen:
					если nextblk.nTime < bestnextblk.nTime:
						bestchainlen = chainlen
						bestnextblk = nextblk
			blk.next = [bestnextblk]
		blk.next = blk.next [0]
		curblkidx + 1 =
		BLK = blk.next
	
	BLK = rootblk
	в то время как BLK:
		#Распечатать "% Я% я% .3f 0x% 08X" % (blk.blocknum, blk.nTime, get_difficulty (blk.nBits), blk.nBits)
		avghashes = 2 ** 256 / uint256_from_compact (blk.nBits)
		Распечатать "% Я% я% я" % (Blk.blocknum, blk.nTime, avghashes)
		BLK = blk.next

если __name__ == "__главный__":
	печать readblocks ("/path/to/blk0001.dat")

* / 1 * * * * /path/to/getblockdata.py > / Путь / к / blockdata