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()
