def Patikra(): p = RawProxy() BHeight = 277316 BHash = p.getblockhash(BHeight) Block = p.getblock(BHash) BVer = Block['version'] BPrevHash = Block['previousblockhash'] BNonce = Block['nonce'] BTime = Block['time'] BMerkle = Block['merkleroot'] BBits = Block['bits'] BPrevHash = SwapOrder(BPrevHash) BMerkle = SwapOrder(BMerkle) BBits = SwapOrder(BBits) BNonce = Endian(BNonce) BTime = Endian(BTime) BVer = Endian(BVer) Hex = (BVer + BPrevHash + BMerkle + BTime + BBits + BNonce) HexBinary = codecs.decode(Hex, 'hex') Hash1 = hashlib.sha256(HexBinary).digest() Hash2 = hashlib.sha256(Hash1).digest() Hash3 = codecs.encode(Hash2[::-1], 'hex_codec') FinalHash = codecs.decode(Hash3) print("Block Hash", BHash) print("Verified Block Hash", FinalHash)
def get_txs(block_height): p = RawProxy() blockhash = p.getblockhash(block_height) block = p.getblock(blockhash) transactions = block['tx'] for txid in transactions: print txid
def search_for_block_by_height(height): p = RawProxy() try: int_height = int(height) block_hash = p.getblockhash(int_height) return search_for_block_by_header(block_hash) except: return None
def get_blockhash(): p = RawProxy() print('Iveskite tikrinamo bloko numeri') height = input() try: blockhash = p.getblockhash(int(height)) return blockhash except Exception as e: logging.error(traceback.format_exc()) globals.control = 0 return
def checkBlock(): hexcoding = 'hex_codec' p = RawProxy() blockId = raw_input("Enter Block Id: ") blockhash = p.getblockhash(int(blockId)) block = p.getblock(blockhash) version = block['versionHex'] hashPrevBlock = block['previousblockhash'] hashMerkleRoot = block['merkleroot'] time = block['time'] bits = block['bits'] nonce = block['nonce'] nonce = hex(int(0x100000000) + int(nonce))[-8:] time = hex(int(0x100000000) + int(time))[-8:] version = (version.decode(hexcoding))[::-1].encode(hexcoding) hashPrevBlock = (hashPrevBlock.decode(hexcoding))[::-1].encode(hexcoding) hashMerkleRoot = (hashMerkleRoot.decode(hexcoding))[::-1].encode(hexcoding) time = (time.decode(hexcoding))[::-1].encode(hexcoding) bits = (bits.decode(hexcoding))[::-1].encode(hexcoding) nonce = (nonce.decode(hexcoding))[::-1].encode(hexcoding) header_hex = (version + hashPrevBlock + hashMerkleRoot + time + bits + nonce) header_bin = header_hex.decode('hex') hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest() print("Calculated hash:") print(hash[::-1].encode(hexcoding)) print("First hash:") print(blockhash)
from bitcoin.rpc import RawProxy from hashlib import sha256 p = RawProxy() blockNum = input("write a block's number:\n") block = p.getblock(p.getblockhash(blockNum)) header = format(block['nonce'], 'x') + str(block['bits']) + format(block['time'], 'x') + str(block['merkleroot']) + str(block['previousblockhash']) + str(block['versionHex']) # convert to little indian indian_header = "" header = header[::-1] for i in range(0, len(header), 2): indian_header += header[i+1] indian_header += header[i] # hashing, "borrowed" from https://en.bitcoin.it/wiki/Block_hashing_algorithm header_binary = indian_header.decode('hex') hash = sha256(sha256(header_binary).digest()).digest() hash = hash[::-1].encode('hex_codec') print("\nGotten hash:\n" + hash) print("Block's hash:\n" + block['hash']) print("Are they the same?") print(hash == block['hash'])
class BlockThread(threading.Thread): """ A block, a thread. """ p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F mod_sqrt_power = (p + 1) // 4 def __init__(self, args=()): super(BlockThread, self).__init__() self.queue = args[0] self.rpc_addr = args[1] self.rpc_port = args[2] self.proxy = None self.nblock = 0 self._stop_event = threading.Event() def init_rpc_co(self): try: if (self.rpc_addr): self.proxy = RawProxy(service_url=self.rpc_addr, service_port=self.rpc_port) else: self.proxy = RawProxy(service_port=self.rpc_port) except Exception as e: perror("Unable to connect: " + str(e)) def modular_sqrt(self, a): """ Return n where n * n == a (mod p). If no such n exists, an arbitrary value will be returned. From pycoin. """ return pow(a, self.mod_sqrt_power, self.p) def get_y(self, x, sign): """ Get the Y coordinate from a compressed key. -x: x coordinate -sign: sign of Y """ y_squared = (x**3 + 7) % self.p y = self.modular_sqrt(y_squared) if (sign == "02" and y & 1) or (sign == "03" and not y & 1) : return -y % self.p else: return y def run(self): while(1): if self.stopped() and self.nblock == 0: logging.info('%s Stopped', self.name) break if self.nblock: self.init_rpc_co() #logging.info('%s running with %s', self.name, self.nblock) keys = [] bhash = self.proxy.getblockhash(self.nblock) block = self.proxy.getblock(bhash) for txid in block['tx']: data = self._get_keys(txid, self.nblock) if data == None or len(data) == 0: continue keys += data keys = dict((x[2], x) for x in keys).values() # delete duplicates in list for elt in keys: if self.queue.full(): self.queue.join() self.queue.put(elt) self.nblock = 0 self.proxy.close() self.proxy = None return def _get_keys(self, txid, block): """ Retrieve all keys from a transaction and construct a list according to the db schema. -txid: transaction id -block: block number """ tx = self.proxy.getrawtransaction(txid) tx_d = self.proxy.decoderawtransaction(tx) keys = [] return_keys = [] for elt in tx_d['vin']: if 'coinbase' in elt.keys(): continue if 'txinwitness' in elt.keys(): tab = elt['txinwitness'] elif 'scriptSig' in elt.keys(): sc = elt['scriptSig'] tab = [x for x in sc['asm'].split(' ')] #If there is a redeem script rds = [x for x in tab if x[0] == '5'] if (len(rds) > 0): for x in rds: keys += [p for p in self.proxy.decodescript(x)['asm'].split(' ') if p[0:2] in ['02', '03', '04']] else: keys += [p for p in tab if p[0:2] in ['02', '03', '04']] for key in keys: sign = key[:2] if sign != "04": #Because sometimes very strange keys, and also because #there are "0" if (len(key) < 60 or len(key) > 70): continue sx = '0x' + key[2:].upper() x = int(sx, 16) y = self.get_y(x, sign) sy = "%X" % y #keys.append([tx, nblock, hash, ]) else: if (len(key) < 120 or len(key) > 136): continue sx = key[2:66].upper() x = int(sx, 16) sy = key[66:].upper() y = int(sy, 16) hash = P2PKHBitcoinAddress.from_pubkey(bytes.fromhex(key), 0) return_keys.append([block, txid, str(hash), sx, sy]) return return_keys def is_working(self): """ Return True if working. """ if self.nblock: return True else: return False def set_block(self, nblock): """ Set self.nblock. -nblock: block number """ self.nblock = nblock def stop(self): self._stop_event.set() def stopped(self): return self._stop_event.is_set()
from bitcoin.rpc import RawProxy import hashlib import sys import struct p = RawProxy() height = sys.argv[1] block_hash = p.getblockhash(int(height)) block_header = p.getblockheader(block_hash) def little_endian(value, is_number = False): if is_number == True: value = struct.pack("<I", value).encode('hex') return value else: binary = value.decode('hex') value = binary[::-1].encode('hex_codec') return value header_hex = str(little_endian(block_header['versionHex']) + little_endian(block_header['previousblockhash']) + little_endian(block_header['merkleroot']) + str(little_endian(block_header['time'], is_number=True)) + little_endian(str(block_header['bits'])) + str(little_endian(block_header['nonce'], is_number=True))) header_bin = header_hex.decode('hex') hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest() calculated_hash = hash[::-1].encode('hex_codec') print(block_hash) print(calculated_hash) if block_hash == calculated_hash:
from bitcoin.rpc import RawProxy from datetime import datetime import sys p = RawProxy() block_hash = p.getblockhash(int(sys.argv[1])) block = p.getblock(block_hash) block_info = p.getblockstats(block_hash) date_time = datetime.fromtimestamp(block['time']) multiplier = 1e-8 result = [str(block['height']), block['hash'], block['previousblockhash'], str(date_time), str(block['confirmations']), str(block['nonce']), str(block_info['txs']), str(block_info['total_out']*multiplier) + " BTC", str(block_info['totalfee']*multiplier) + " BTC"] print(result)
#!/usr/bin/env python3 import codecs from bitcoin.rpc import RawProxy if __name__ == '__main__': conf = input('Please enter path to the configuration file: ') proxy = RawProxy(btc_conf_file=conf) numblocks = proxy.getblockcount() + 1 fp = codecs.open('out.csv', 'w', 'utf-8') for idx in range(numblocks): blockinfo = proxy.getblock(proxy.getblockhash(idx)) fp.write(','.join( map(str, [ blockinfo['height'], blockinfo['time'], blockinfo['difficulty'], ])) + '\n') fp.close() # End of File
if endBlock >= startBlock: totalBlocks = endBlock - startBlock else: print("Warning: end block is smaller then start block") print(label0) print("") option = int(input("Choose an option: ")) print(label0) while index <= totalBlocks: blockValue = 0 heightOfBlock = startBlock + index blockHash = p.getblockhash(heightOfBlock) block = p.getblock(blockHash) transactions = block['tx'] for txid in transactions: transactionValue = 0 rawTransactions = p.getrawtransaction(txid) decoded_tx = p.decoderawtransaction(rawTransactions) for output in decoded_tx['vout']: transactionValue = transactionValue + output['value'] blockValue = blockValue + transactionValue
from bitcoin.rpc import RawProxy import hashlib p = RawProxy() # Big-endian values to little-endian # naudotas https://www.reddit.com/r/learnpython/comments/2m65dy/endianness_conversion_of_hex_values_in_python_2x/ def swap(member): sz = bytearray.fromhex(member) sz.reverse() x = ''.join(format(a, '02x') for a in sz) #dvejetaine sistema return x # The block height where Alice's transaction was recorded blockheight = 245615 block_hash = p.getblockhash(blockheight) #is uzduoties pvz block = p.getblock(block_hash) # Headeris #Cia viskas sukeiciama i bitus versionHex = swap(block["versionHex"]) previousblockhash = swap(block["previousblockhash"]) merkleroot = swap(block["merkleroot"]) time = swap('{:02x}'.format(block["time"])) #keiciama atskirai bits = swap(block["bits"]) nonce = swap('{:02x}'.format(block["nonce"])) #keiciama atskirai head = (versionHex + previousblockhash + merkleroot + time + bits + nonce) #viskas sudedama #viskas vel verciama i 16-ne head_bin = head.decode('hex')
'meanSPB': meanSPB_legacy, 'minSPB': minSPB_legacy, 'firstQuartileSPB': firstQuartileSPB_legacy, 'medianSPB': medianSPB_legacy, 'thirdQuartileSPB': thirdQuartileSPB_legacy, 'maxSPB': maxSPB_legacy, 'standardDeviationSPB': stdSPB_legacy }, 'Height': height, 'Timestamp': block_timestamp, 'Hash': blockhash }) while startingHeight < p.getblock(p.getbestblockhash())['height']: startingHeight += 1 print('Block height: ' + str(startingHeight)) blockhash = p.getblockhash(startingHeight) block = p.getblock(blockhash) process_block(startingHeight, blockhash) fw.close() sorted_list = sorted(data, key=lambda k: int(k['Height']), reverse=False) shutil.copyfile(jsonfile, 'public/data.json.last') with open(jsonfile, 'w') as outfile: json.dump(sorted_list, outfile, sort_keys=True)
print(a) #check if hash is correct def swapOrder(data): x = "" k = len(data) / 2 for i in range(0, k): byte = data[2 * i] + data[2 * i + 1] x = byte + x return x block_hash = p.getblockhash(605730) block = p.getblock(block_hash) header = (swapOrder(block["versionHex"]) + swapOrder(block["previousblockhash"]) + swapOrder(block["merkleroot"]) + swapOrder('{:08x}'.format(block["time"])) + swapOrder(block["bits"]) + swapOrder('{:08x}'.format(block["time"]))) header_bin = header.decode('hex') check = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest() print("Checked hash: ") print check[::-1].encode('hex_codec') print("Hash: ") print block['hash']
from bitcoin.rpc import RawProxy, JSONRPCError, InvalidParameterError from bitcoin.core import lx, b2x, b2lx; from bitcoin.core.serialize import Hash p = RawProxy() block_hash = None while True: try: blockheight = int(raw_input("Enter block's height: ")) block_hash = p.getblockhash(blockheight) break except ValueError: print("Invalid value, please enter an integer") except (InvalidParameterError, JSONRPCError, KeyError): print("Ivalid parameter, block with such height does not exist") block = p.getblock(block_hash) print(block_hash) version_hex = block['versionHex'] prev_block_hash = block['previousblockhash'] if 'previousblockhash' in block else '0' * 64 merkle_root = block['merkleroot'] time = block['time'] diff_bitts = block['bits'] nonce = block['nonce'] print("%s %s" % ("\nBlock's hash:", block_hash)) print("\nProperties:") print("%s %s" % ("Version hex:", version_hex)) print("%s %s" % ("Previous block hash:", prev_block_hash))
from struct import pack, unpack, unpack_from from binascii import unhexlify import datetime, calendar import sys import hashlib import binascii p = RawProxy() if len(sys.argv) != 2: print("Too many arguments or no block height passed!") sys.exit() height = int(sys.argv[1]) blockHash = p.getblockhash(height) block = p.getblock(blockHash) version = block['version'] hashPrevBlock = block['previousblockhash'].decode('hex') merkle = block['merkleroot'].decode('hex') timestamp = block['time'] bits = block['bits'] nonce = block['nonce'] version = pack('<I', version).encode('hex_codec') hashPrevBlock = hashPrevBlock[::-1].encode('hex_codec') merkle = merkle[::-1].encode('hex_codec') timestamp = pack('<I', timestamp).encode('hex_codec') bits = pack('<I', int(bits, 16)).encode('hex_codec')
# RPC 패키지 : https://github.com/petertodd/python-bitcoinlib from bitcoin.rpc import RawProxy import pandas as pd import numpy as np import matplotlib.pyplot as plt # Bitcoin Core에 접속한다. p = RawProxy() # 블록체인의 블록 개수을 읽어온다 n = p.getblockcount() # 최근 1000개 블록의 헤더를 읽어서 생성 시간을 조회한다. header = [] for i in range(n - 999, n + 1): bHash = p.getblockhash(i) hdr = p.getblockheader(bHash) height = hdr['height'] btime = hdr['time'] bhash = hdr['hash'] header.append([height, btime, bhash]) df = pd.DataFrame(header, columns=['Height', 'Time', 'Hash']) sdf = df.sort_values('Time') sdf = sdf.reset_index() print(df.to_string()) print('총 %d 개 블록 헤더를 읽어왔습니다.' % len(df)) # 블록 생성 소요 시간 분포 관찰 mtime = sdf['Time'].diff().values mtime = mtime[np.logical_not(np.isnan(mtime))]
import hashlib from struct import pack, unpack, unpack_from from bitcoin.rpc import RawProxy p = RawProxy() a = int(input("Iveskite bloko numeri: ")) blockhash = p.getblockhash(a) block = p.getblock(blockhash) version = pack('<I', block['version']).encode('hex') prevBlockHash = (block['previousblockhash'].decode('hex'))[::-1].encode('hex') rootHash = (block['merkleroot'].decode('hex'))[::-1].encode('hex') time = pack('<I', block['time']).encode('hex') bits = (block['bits'].decode('hex'))[::-1].encode('hex') nonce = pack('<I', block['nonce']).encode('hex') header_hex = (version + prevBlockHash + rootHash + time + bits + nonce) header_bin = header_hex.decode('hex') hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest() print("Gautas hash: " + hash[::-1].encode('hex')) print("Bloko hash: " + blockhash)
from bitcoin.rpc import RawProxy from hashlib import sha256 import binascii import struct def hexify(value, type): return binascii.hexlify(struct.Struct(type).pack(value)) p = RawProxy() blockheight = 1337 blockhash = p.getblockhash(blockheight) block = p.getblock(blockhash) block_version = block['version'] previous_hash = block['previousblockhash'] hash_merkle_root = block['merkleroot'] bits = block['bits'] timestamp = block['time'] nonce = block['nonce'] header_hex = '{block_version}{previous_hash}{hash_merkle_root}{timestamp}{bits}{nonce}'.format( block_version=hexify(block_version, '<L'), previous_hash=binascii.hexlify(previous_hash.decode('hex')[::-1]), hash_merkle_root=binascii.hexlify(hash_merkle_root.decode('hex')[::-1]), timestamp=hexify(timestamp, '<L'), bits=binascii.hexlify(bits.decode('hex')[::-1]), nonce=hexify(nonce, '<L'))
# Function for converting from big-endian to littl-endian (switch most significant with least significant byte at the front) def endianConversion(input1): ba = bytearray.fromhex(input1) ba.reverse() result = ''.join(format(x, '02x') for x in ba) return result p = RawProxy() # Write down basic block informaction blockHeight = int(sys.argv[1]) blockHash = p.getblockhash(blockHeight) blockHeader = p.getblock(blockHash) # Gets the full header information in hex format fullHeader = (endianConversion(blockHeader['versionHex']) + endianConversion(blockHeader['previousblockhash']) + endianConversion(blockHeader['merkleroot']) + endianConversion('{:02x}'.format(blockHeader['time'])) + endianConversion(blockHeader['bits']) + endianConversion('{:02x}'.format(blockHeader['nonce']))) binHeader = fullHeader.decode('hex') # Calculates the hash based on the header information calculatedHash = hashlib.sha256(hashlib.sha256(binHeader).digest()).digest()