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 search_for_block_by_header(header): p = RawProxy() try: block_info = p.getblock(header) block_info['resulttype'] = 'block' return block_info except: return None
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 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 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'))
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']
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 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'])
#!/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
fw = open('public/transtats.txt', 'w') writer = csv.writer(fw) jsonfile = 'public/data.json' data = [] if os.path.exists(jsonfile): with open(jsonfile) as json_data: if os.stat(jsonfile).st_size > 0: data = json.load(json_data) else: open(jsonfile, 'w') firstSegwitBlock = 481824 currentHeight = p.getblock(p.getbestblockhash())['height'] startingHeight = currentHeight - 12 def process_block(height, blockhash): print('processing block: height=%d hash=%s' % (height, blockhash)) thisBlockJson = filter(lambda block: block['Height'] == height, data) if len(thisBlockJson): if thisBlockJson[0]["Height"] == height and thisBlockJson[0][ "Hash"] == blockhash: print('* already processed in db') return
import matplotlib.pyplot as plt # Bitcoin Core에 접속한다. p = RawProxy() def getUtxo(x, n): tt = p.getrawtransaction(x, True) return tt['vout'][n]['value'] # 블록체인 tip (끝 부분)의 hash, height를 읽어온다 tip = p.getchaintips() # 마지막 블록을 읽어온다 height = tip[0]['height'] bHash = tip[0]['hash'] block = p.getblock(bHash) # 마지막 블록의 Tx를 읽는다. nTx = len(block['tx']) # Tx를 차례대로 읽어가면서 Fee를 계산한다. (Coinbase Tx는 제외) txFee = [] byteFee = [] accByteFee = [] cnt = 0 for i in range(1, nTx): txid = block['tx'][i] tx = p.getrawtransaction(txid, True) # total Input value를 계산한다 nIn = len(tx['vin'])
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') nonce = pack('<I', nonce).encode('hex_codec')
# 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() if calculatedHash[::-1].encode('hex_codec') == blockHeader['hash']: