def main(): print('Starting ingestion at height %d' % start) connection = mysql.connector.connect(host=mysql_host, user=mysql_user, database=mysql_database, port=mysql_port, password=mysql_password) cursor = connection.cursor() blockchain = Blockchain(path, cache=block_index_cache) for block, block_undo in blockchain.get_ordered_blocks(start=start, end=end): t = time.time() if block_undo is None: continue block_data = to_block_data(blockchain, block, block_undo) insert_block_data(connection, block_data) print(time.time(), time.time() - t, block.height, 'block_count') cursor.close() connection.close()
def extract_input_output_main_from_blockchain(request): start = 0 stop = 0 if 'start' in request.GET: start = int(request.GET['start']) if 'stop' in request.GET: stop = int(request.GET['stop']) blockchain = Blockchain(BLOCK_DATA_DIR) print("blocks accessed") threads = [] for block in blockchain.get_ordered_blocks(BLOCK_DATA_DIR + '/index', start=start, end=stop): thread1 = myThread(block) thread1.start() threads.append(thread1) for thread in threads: thread.join() count_thread = threading.active_count() while count_thread > MAX_NUM_OF_THREAD: print("threading active_count >>>>>>>>>>>>" + str(count_thread)) continue return JsonResponse({"res": ""}, status=200)
def noncesRelatedToBitiodineAddresses(self, caddresses, ctag): filem = UtilFileManager() arqName = "ClusterNoncesOutput_" + self.clusterType + "_" + str(ctag) countFindings = 0 blockNumber = 0 blockchain = Blockchain( os.path.expanduser(sp.configBlockchainPath + 'blocks')) for block in blockchain.get_ordered_blocks( os.path.expanduser(sp.configBlockchainPath + "blocks/index"), start=0): blockNumber = blockNumber + 1 nonce = block.header.nonce transaction = block.transactions[0] #Get outputs from coinbase transaction for output in transaction.outputs: #Get addresses for outAddr in output.addresses: for strAddr in caddresses: if outAddr._address == strAddr: #save that nonce filem.saveInFile(arqName, nonce) self.append(nonce) countFindings = countFindings + 1 if countFindings > 0: scalc = Statistics() scalc.printStatistics("Nonces", arqName, filem) return countFindings
def main(): blockchain = Blockchain( os.path.expanduser( '/media/varun/DATA/Courses/Capstone/PyBC/pybit/Blocks') ) #D:\Courses\Capstone\PyBC\pybit\Blocks acc_btc_per_address = {} script_count = {} script_count["p2pk"] = 0 script_count["p2pkh"] = 0 script_count["p2ms"] = 0 script_count["p2sh"] = 0 for block in blockchain.get_unordered_blocks(): for tx in block.transactions: for output in tx.outputs: address = output.addresses if output.is_pubkey(): script_count["p2pk"] += 1 elif output.is_pubkeyhash(): script_count["p2pkh"] += 1 elif output.is_multisig(): script_count["p2ms"] += 1 elif output.is_p2sh(): script_count["p2sh"] += 1 else: continue if address[0] in acc_btc_per_address.keys(): acc_btc_per_address[address[0]] = acc_btc_per_address[ address[0]] + output.value else: acc_btc_per_address[address[0]] = output.value analyze = {} analyze["0-1"] = 0 analyze["1-10"] = 0 analyze["10-100"] = 0 analyze["100-1000"] = 0 analyze["1000-10000"] = 0 analyze["10000-100000"] = 0 analyze[">=100000"] = 0 for address in acc_btc_per_address.keys(): btc_value = acc_btc_per_address[address] / 100000000 if btc_value < 1: analyze["0-1"] += 1 elif btc_value >= 1 and btc_value < 10: analyze["1-10"] += 1 elif btc_value >= 10 and btc_value < 100: analyze["10-100"] += 1 elif btc_value >= 100 and btc_value < 1000: analyze["100-1000"] += 1 elif btc_value >= 1000 and btc_value < 10000: analyze["1000-10000"] += 1 elif btc_value >= 10000 and btc_value < 100000: analyze["10000-100000"] += 1 elif btc_value >= 100000: analyze[">=100000"] += 1 print(analyze) for script in script_count.keys(): print("Address type:", script, "count:", script_count[script])
def main(): uri = "bolt://localhost:7687" driver = GraphDatabase.driver(uri, auth=("neo4j", "n")) blockchain = Blockchain( os.path.expanduser( '/media/varun/DATA/Bitcoin data/Blockdata_testing/1')) blocks = blockchain.get_unordered_blocks() with driver.session() as session: #session.write_transaction(create_addresses, blocks) create_inputs(session, blocks) create_outputs(session, blocks) # with driver.session() as session: # create_outputs(session, blocks) # session.write_transaction(create_blocks,blocks) # with driver.session() as session2: # session2.write_transaction(create_transaction, blocks) # tx_hash_handle = open("txhash_00.txt","w+") # tx_index = open("txindex_00.txt", "w+") # #D:\Courses\Capstone\PyBC\pybit\Blocks # for block in blockchain.get_unordered_blocks(): # for tx in block.transactions: # for input in tx.inputs: # tx_hash_handle.write(str(input.transaction_hash)+"\n") # tx_index.write(str(input.transaction_index)+"\n") # # tx_hash_handle.flush() # tx_index.flush() # tx_index.close() # tx_hash_handle.close() driver.close()
def main(): blockchain = Blockchain(os.path.expanduser('./blocks')) for block in blockchain.get_unordered_blocks(): for tx in block.transactions: for no, output in enumerate(tx.outputs): print(tx.hash, output.addresses, output.value) sys.exit(0)
def main(): blockchain = Blockchain( os.path.expanduser( '/media/varun/DATA/Courses/Capstone/PyBC/pybit/Blocks')) for block in blockchain.get_unordered_blocks(): for transaction in block.transactions: for output in transaction.outputs: if output.is_unknown(): print(block.header.timestamp, output.script.value)
def main(): blockchain = Blockchain( os.path.expanduser( '/media/varun/DATA/Courses/Capstone/PyBC/pybit/Blocks') ) #D:\Courses\Capstone\PyBC\pybit\Blocks for block in blockchain.get_unordered_blocks(): for tx in block.transactions: for no, output in enumerate(tx.outputs): print("tx=%s outputno=%d type=%s value=%s" % (tx.hash, no, output.type, output.value))
def process(self): count = 0 blockchain = Blockchain(os.path.expanduser('~/.bitcoin/blocks')) for block in blockchain.get_unordered_blocks(): timestamp = block.header.timestamp if (timestamp.year == 2017): for tx in block.transactions: self.output_queue.put((tx, block.header.timestamp)) self.output_queue.put(None) #ending condition
def process(self): count = 0 blockchain = Blockchain(os.path.expanduser('~/.bitcoin/blocks')) for block in blockchain.get_ordered_blocks(os.path.expanduser( '/home/teh_devs/Downloads/bitcoin_analysis_sa/index'), start=self.start_block, end=self.end_block): for tx in block.transactions: self.output_queue.put((tx, block.header.timestamp)) self.output_queue.put(None) #ending condition
def get_block_transactions(block_height): blockchain = Blockchain("datas") for block in blockchain.get_ordered_blocks( "datas/index", end=block_height, start=block_height + 1, cache="super-big-index.pickle", ): print(block.height) for tx in block.transactions: yield tx
def main(): prepare_dirs() blockchain = Blockchain(BLOCK) #build_address_db(blockchain, INDEX, end=200001) #print('Building Address DB done') for block in blockchain.get_ordered_blocks(INDEX, start=200000, end=210000): result = process_block(block) archive_result(result, block.height) print('Done: {0:d} - {1:s}'.format(block.height, block.hash))
def __init__(self, chain, chainpath): self.chain = chain self.chainpath = chainpath self.last_block = 0 if not os.path.isdir("txdata"): os.mkdir("txdata") try: f = open("txdata/" + self.chain + "-balances.pickle", "rb") self.balances = pickle.load(f) except: self.balances = {} self.blockchain = Blockchain(os.path.expanduser(self.chainpath), chain_const[self.chain]["pch"])
def main(): blockchain = Blockchain( os.path.expanduser( '/media/varun/DATA/Courses/Capstone/PyBC/pybit/Blocks') ) #D:\Courses\Capstone\PyBC\pybit\Blocks trans_per_address = {} same_transaction_counter = 0 for block in blockchain.get_unordered_blocks(): for tx in block.transactions: for output in tx.outputs: address = output.addresses if len(address) != 0: if address[0] in trans_per_address.keys(): same_transaction_counter += 1 trans_per_address[address[0].hash] += 1 else: trans_per_address[address[0].hash] = 1 analyze = {} analyze["1-2"] = 0 analyze["2-4"] = 0 analyze["4-10"] = 0 analyze["10-100"] = 0 analyze["100-1000"] = 0 analyze["1000-10000"] = 0 analyze["10000-100000"] = 0 analyze[">=100000"] = 0 for address in trans_per_address.keys(): trans_value = trans_per_address[address] if trans_value < 2: analyze["1-2"] += 1 elif trans_value >= 2 and trans_value < 4: analyze["2-4"] += 1 elif trans_value >= 4 and trans_value < 10: analyze["4-10"] += 1 elif trans_value >= 10 and trans_value < 100: analyze["10-100"] += 1 elif trans_value >= 100 and trans_value < 1000: analyze["100-1000"] += 1 elif trans_value >= 1000 and trans_value < 10000: analyze["1000-10000"] += 1 elif trans_value >= 10000 and trans_value < 100000: analyze["10000-100000"] += 1 elif trans_value >= 100000: analyze[">=100000"] += 1 print(analyze) print(same_transaction_counter)
def main(): blockchain = Blockchain( os.path.expanduser( '/media/varun/DATA/Courses/Capstone/PyBC/pybit/Blocks') ) #D:\Courses\Capstone\PyBC\pybit\Blocks timelist = [] n_transactions = {} n_transactions_count = 0 n_col_transactions = [] # transactions with the same txid block_counter = 0 tx_per_block = {} for block in blockchain.get_unordered_blocks(): block_counter += 1 timelist.append(block.header.timestamp) tx_counter = 0 for tx in block.transactions: n_transactions_count += 1 tx_counter += 1 if tx.txid in n_transactions.keys(): n_transactions[tx.txid].append( block.header.timestamp) #adding timestamp to the n_col_transactions.append(tx.txid) else: n_transactions[tx.txid] = [] n_transactions[tx.txid].append(block.header.timestamp) # for no, output in enumerate(tx.outputs): # print("tx=%s outputno=%d type=%s value=%s" % (tx.hash, no, output.type, output.value)) tx_per_block[block.hash] = tx_counter print("the start date: ", min(timelist), "the end date", max(timelist), "of the datset") print("Total number of Transactions:", n_transactions_count) for txid in n_col_transactions: print("Same hash collision hash:", txid, "at time", n_transactions[txid], "boolean segwit: ", tx.is_segwit, "boolean isCoinbase:", tx.is_coinbase()) print("total number of blocks in the datset are:", block_counter) max_transaction_inblock = max(tx_per_block, key=tx_per_block.get) print("The maximum transactions in a block are: ", tx_per_block[max_transaction_inblock], "in block", max_transaction_inblock) min_transaction_inblock = min(tx_per_block, key=tx_per_block.get) print("The minimum transactions in a block are: ", tx_per_block[min_transaction_inblock], "in block", min_transaction_inblock)
def main(): blockchain = Blockchain( os.path.expanduser( '/media/varun/DATA/Courses/Capstone/PyBC/pybit/Blocks') ) #D:\Courses\Capstone\PyBC\pybit\Blocks max_btc_per_address = {} for block in blockchain.get_unordered_blocks(): for tx in block.transactions: for output in tx.outputs: address = output.addresses if len(address) != 0: if address[0] in max_btc_per_address.keys(): if max_btc_per_address[address[0]] < output.value: max_btc_per_address[address[0]] = output.value else: max_btc_per_address[address[0]] = output.value analyze = {} analyze["0-0.1"] = 0 analyze["0.1-10"] = 0 analyze["10-100"] = 0 analyze["100-1000"] = 0 analyze["1000-10000"] = 0 analyze["10000-100000"] = 0 analyze[">=100000"] = 0 for address in max_btc_per_address.keys(): btc_value = max_btc_per_address[address] / 100000000 if btc_value < 0.1: analyze["0-0.1"] += 1 elif btc_value >= 1 and btc_value < 10: analyze["0.1-10"] += 1 elif btc_value >= 10 and btc_value < 100: analyze["10-100"] += 1 elif btc_value >= 100 and btc_value < 1000: analyze["100-1000"] += 1 elif btc_value >= 1000 and btc_value < 10000: analyze["1000-10000"] += 1 elif btc_value >= 10000 and btc_value < 100000: analyze["10000-100000"] += 1 elif btc_value >= 100000: analyze[">=100000"] += 1 print(analyze)
def main(): blockchain = Blockchain( os.path.expanduser( '/media/varun/DATA/Courses/Capstone/PyBC/pybit/Blocks')) for block in blockchain.get_unordered_blocks(): for transaction in block.transactions: coinbase = transaction.inputs[0] # Some coinbase scripts are not valid scripts try: script_operations = coinbase.script.operations except CScriptInvalidError: break # An operation is a CScriptOP or pushed bytes for operation in script_operations: if type(operation) == bytes and len(operation) > 3 \ and is_ascii_text(operation): print(block.header.timestamp, operation.decode("ascii")) break
def main(): height = 0 if os.path.exists(progress_file): with open(progress_file) as f: height = f.readline().rstrip() if height == 'COMPLETE': print('Ingestion is complete') sys.exit(0) height = int(height) + 1 print('Starting ingestion at height %d' % height) connection = mysql.connector.connect(host=mysql_host, user=mysql_user, database=mysql_database, password=mysql_password) cursor = connection.cursor() blockchain = Blockchain(path, cache=block_index_cache) for block, block_undo in blockchain.get_ordered_blocks(start=height): t = time.time() if block_undo is None: continue block_data = to_block_data(blockchain, block, block_undo) insert_block_data(connection, block_data) with open(progress_file, 'w') as f: f.write(str(block.height) + '\n') print(time.time(), time.time() - t, block.height, 'block_count') with open(progress_file, 'w') as f: f.write('COMPLETE\n') cursor.close() connection.close()
def process_block(block): client = MongoClient("mongodb://localhost:27017") ba = client["ba"] utxo = ba["utxo"] for tx in block.transactions: tx_hash = tx.hash result = utxo.find({"tx_hash":tx_hash}).count() if result > 0: pass with open('missing_tx', "a") as outfile: outfile.write((tx_hash + '\n')) for index,output in enumerate(tx.outputs): try: document = { "tx_hash":tx_hash, "index":index, "address":output.addresses[0].address, "amount":output.value / 100000000 } utxo.insert(document) except Exception as e: f = open('logs', 'a') f.write(e) f.write("TX HASH" + str(tx_hash)+ '\n') f.close() # Free RAM del block gc.collect() blockchain = Blockchain(os.path.expanduser('/home/shared/bitcoin/blocks')) count = 0 encountered = False for block in blockchain.get_ordered_blocks(os.path.expanduser('~/.bitcoin/blocks/index'), end=1000): print("height=%d block=%s" % (block.height, block.hash)) process_block(block)
def read_data(self, show_progress: bool = False): """ 从区块数据生成器里依次构建 :param show_progress: 是否显示进度 :return: """ block_chain = Blockchain(self.dir_blocks) index = 0 for i, block in enumerate( block_chain.get_ordered_blocks(index=self.dir_index, cache=self.index_cache)): if block.height < self.min_height: continue if block.height > self.max_height: break index += 1 self.from_block(block) if show_progress: rate = index / (self.max_height - self.min_height + 1) sys.stdout.write( f'已完成 {rate * 100:.1f}% -- {index}/{self.max_height - self.min_height + 1}\r' ) sys.stdout.flush()
def parse(filepath, filename): target_path = "/data/result/" j = filename.split(".") add_str = j[0] file_blk = open(target_path + add_str + ".blk.txt",'a') file_trans = open(target_path + add_str + ".trans.txt",'a') file_input = open(target_path + add_str + ".input.txt",'a') file_output = open(target_path + add_str + ".output.txt",'a') blockchain = Blockchain(os.path.expanduser(filepath + filename)) for block in blockchain.get_unordered_blocks(): file_blk.write(block.hash +"\t"+ str(block.size) +"\t"+ str(block.header.version) +"\t"+ block.header.previous_block_hash +"\t"+ block.header.merkle_root + "\t"+ str(block.header.timestamp) +"\t"+ str(block.header.bits) +"\t"+ str(block.header.nonce) +"\t"+ str(block.n_transactions) + "\t" + add_str + "\n") for tx_index,tx in enumerate(block.transactions): try: file_trans.write(block.hash + "\t" + str(tx_index) + "\t" + tx.hash + "\t" + str(tx.version) + "\t" + str(tx.locktime) + "\t" + str(tx.n_inputs) + "\t" + str(tx.n_outputs) + "\t" + str(tx.is_segwit) + "\t" + add_str + "\n") for input_index, input in enumerate(tx.inputs): transaction_hash = input.transaction_hash transaction_index = input.transaction_index if tx.is_coinbase(): transaction_hash = "coinbase" transaction_index = 0 file_input.write(tx.hash + "\t" + str(input.sequence_number) + "\t" + transaction_hash+ "\t" + str(transaction_index) + "\t" + add_str + "\n") for output_index, output in enumerate(tx.outputs): address_list = [] for address in output.addresses: address_list.append(address.address) file_output.write(tx.hash + "\t" + str(output_index) + "\t" + output.type+ "\t" + ",".join(address_list)+ "\t" + str(output.value) + "\t" + add_str + "\n") except Exception as e: print(e) file_blk.close() file_trans.close() file_input.close() file_output.close()
def process_chunk(BLOCK_PATH, INDEX_PATH, start): """ Processes a chunk of Bitcoin blocks (start to start+1000) and returns the transaction outputs :param BLOCK_PATH: str, the path to the Bitcoin blocks :param INDEX_PATH: str, the path to the LevelDB Bitcoin index :param start: int, the block height to start at :return: list, a list of tuples. One tuple per transaction, where each tuple contains the transaction id and a serialized representation of a list of transaction outputs as bytestring. """ re_data = [] # Load Blockchain, ignore Read Locks imposed by other instances of the process blockchain = Blockchain(BLOCK_PATH, ignoreLocks=True) blockchain = blockchain.get_ordered_blocks(INDEX_PATH, start=start, end=start + 1000) for block in blockchain: for tx in block.transactions: tx_id = tx.txid # Create a list of outputs, where each output is itself a list comprising value, receiving address and # output number. outputs = [] for o in range(len(tx.outputs)): try: addr = tx.outputs[o].addresses[0].address val = tx.outputs[o].value outputs.append([val, addr, o]) except Exception as e: val = tx.outputs[o].value outputs.append([val, 'unknown', o]) pass # Add the output list of the transaction and append it to the collector list. Serialization for the # the database is performed here because it is costly and should be done in parallel. re_data.append((tx_id, pickle.dumps(outputs))) return re_data
def __init__(self, *args, **kwargs): super(LoadBLKFilesToStgBase, self).__init__(*args, **kwargs) self.blockchain = Blockchain(self.input())
print('P2SH: ', input_id, full_script) cur = conn.cursor() cur.execute("INSERT INTO p2sh (input_id, full_script) VALUES (%s,%s)", (input_id, full_script)) conn.commit() def writetooutput_script(output_id, full_script): print('OUTPUT_SCRIPT: ', output_id, full_script) cur = conn.cursor() cur.execute("INSERT INTO output_script (output_id, full_script) VALUES (%s,%s)", (output_id, full_script)) conn.commit() def fetch_single_data(table, column, id): cur.execute("SELECT %s FROM %s WHERE id = %s", (column, table, id)) return cur.fetchone() # Instanciate the Blockchain by giving the path to the directory blockchain = Blockchain(sys.argv[1]) print(blockchain.get_main_chain()) #ordere blocks according to height starting with genesis block #orderedblockchain= blockchain.get_main_chain() #print(type(orderedblockchain)) #print(orderedblockchain[0]) #get relevant data from relevant blocks and save to db def saveblockinfo(block): height = block.height id = block.hash header = block.header timestamp = time.mktime(header.timestamp.timetuple()) #writetoblock(id, height, timestamp) writetoblock(id, height, timestamp) #returns type of transaction
import redis import pickle import plyvel from collections import deque from flask import Flask, request, render_template, g from blockchain_parser.blockchain import Blockchain CACHE_RANGE = 200 # first transaction 4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b app = Flask(__name__) red = redis.Redis(host="localhost", port=6379, db=0) red.flushall() blockchain = Blockchain("datas") # force the creation of the index if os.path.exists("super-big-index.pickle"): os.remove("super-big-index.pickle") print("Creating index") next( blockchain.get_ordered_blocks("datas/index", cache="super-big-index.pickle")) print("Index created") pldb = plyvel.DB('tx_to_block/', create_if_missing=False) class IllegalState(Exception):
app.logger.debug("Starting blockchain finder...") app.logger.debug("Connecting to redis...") while True: try: red = redis.Redis(host="redis", port=6379, db=0) red.flushall() app.logger.debug("Redis connection OK") break except: app.logger.debug("Redis not ready yet") time.sleep(1) app.logger.debug("Reading blockchain...") blockchain = Blockchain("/blockchain/blocks") levelDBMap = dict() levelDBMapLock = threading.Lock() def loadIndex(self, index): with levelDBMapLock: if index not in levelDBMap: db = plyvel.DB(index, compression=None) blockIndexes = [ DBBlockIndex(format_hash(k[1:]), v) for k, v in db.iterator() if k[0] == ord('b') ] db.close() blockIndexes.sort(key=lambda x: x.height) levelDBMap[index] = blockIndexes
import os from blockchain_parser.blockchain import Blockchain import datetime import leveldb from binascii import a2b_hex, b2a_hex import pymongo from pymongo import MongoClient import subprocess import urllib start = datetime.datetime.now() blockchain = Blockchain('/data1/bitcoin/blocks/') index_path = '/data1/bitcoin/blocks/index' back_path = '/data/workdir/data/bitcoinparser/bitcoin_index_backup/index' txhash_address = leveldb.LevelDB("/data/workdir/data/bitcoinparser/leveldb/") block_column = [ "height", "hash", "version", "previous_block_hash", "merkle_root", "timestamp", "bits", "difficulty", "nonce", "n_transactions" ] tx_header_column = [ "height", "tx_index", "version", "locktime", "txhash", "n_inputs", "n_outputs", "is_segwit" ] tx_output_column = [ "height", "tx_index", "txhash", "output_num", "value", "address", "script", "type" ] tx_input_column = [ "height", "tx_index", "input_num", "txhash", "transaction_index", "sequence_number", "script", "witnesses", "value", "address"
import sys sys.path.append('..') from blockchain_parser.blockchain import Blockchain from blockchain_parser.script import CScriptInvalidError def is_ascii_text(op): return all(32 <= x <= 127 for x in op) def as_utf8_text(x): try: return x.decode('UTF-8') except UnicodeDecodeError: return None blockchain = Blockchain(sys.argv[1]) for block in blockchain.get_ordered_blocks(sys.argv[1] + '/index'): for transaction in block.transactions: coinbase = transaction.inputs[0] try: script_operations = [op for op in coinbase.script.operations if type(op) == bytes] except CScriptInvalidError: break # An operation is a CScriptOP or pushed bytes for operation in script_operations: text = as_utf8_text(operation) if text and len(operation.strip(b'\x00')) >= 20: # print(block.header.timestamp, text)
import hashlib import binascii from blockchain_parser.blockchain import Blockchain from blockchain_parser.script import CScriptInvalidError def is_ascii_text(op): return all(32 <= x <= 127 for x in op) def hexify(value,zeros): try: return hex(value).replace('0x','').replace('L','').zfill(zeros) except: return value.encode('hex').zfill(zeros) blockchain = Blockchain(sys.argv[1]) h = 0 print("height,version, h0, h1, h2, h3, h4, h5, h6, h7, r0, r1, r2, r3, r4, r5, r6, r7, timestamp, bits, nonce") for block in blockchain.get_unordered_blocks(): header = block.header r = [header.version] r += struct.unpack("<IIIIIIII",binascii.unhexlify(header.previous_block_hash)[::-1]) r += struct.unpack("<IIIIIIII",binascii.unhexlify(header.merkle_root)[::-1]) r += struct.unpack("<I",bytes(header.hex[68:72])) r += [header.bits] r += [header.nonce] print(str(h)+","+str(r).replace("[","").replace("]","")) h += 1
# Copyright (C) 2015 The bitcoin-blockchain-parser developers # # This file is part of bitcoin-blockchain-parser. # # It is subject to the license terms in the LICENSE file found in the top-level # directory of this distribution. # # No part of python-bitcoinlib, including this file, may be copied, modified, # propagated, or distributed except according to the terms contained in the # LICENSE file. import sys from blockchain_parser.blockchain import Blockchain blockchain = Blockchain(sys.argv[1]) for block in blockchain.get_unordered_blocks(): for transaction in block.transactions: for output in transaction.outputs: if output.is_unknown(): print(block.header.timestamp, output.script.value)
from blockchain_parser.blockchain import Blockchain import time start_time = time.time() path = "/Volumes/C/bitcoin-blockchain/blockchain/blocks/" start_file = path + 'blk00000.dat' #years = [2011, 2012, 2013, 2014] years = [2011, 2012] processed_years = set() blockchain = Blockchain(path) for block in blockchain.get_unordered_blocks(): if block.header.timestamp.year in years: new_file = blockchain.selected_blk_file if new_file != start_file or block.header.timestamp.year not in processed_years: processed_years.add(block.header.timestamp.year) start_file = new_file print("File: " + new_file + " Year:" + str(block.header.timestamp.year)) print("--- %s seconds ---" % (time.time() - start_time))
f_list = [float(i) for i in line.split(",") if i.strip()] #colors 003399, 3F5D7D freq, bins, patches = plt.hist(f_list, 256, color="#003399") plt.xlabel(xlabelName, fontsize=16) #, fontsize=25 plt.ylabel("Frequency", fontsize=16) plt.savefig("results/"+xlabelName.strip()+"_chunk"+str(countFileChunk)+".png", bbox_inches="tight") plt.close() os.remove(fileName) #AM file may get big. #the API filters orphan blocks # ##CHANGE HERE TO YOUR CONFIG blockchain = Blockchain(os.path.expanduser('~/snap/bitcoin-core/common/.bitcoin/blocks')) bitcoinlocalpath = '/home/aagiron/snap/bitcoin-core/common/.bitcoin/blocks' #Initial file names LSBytesFileName = "extracted/LSBytesFromEveryNonce_FullBlockchainChunk1.data" Bytes1FileName = "extracted/Bytes1FromEveryNonce_FullBlockchainChunk1.data" Bytes2FileName = "extracted/Bytes2FromEveryNonce_FullBlockchainChunk1.data" MSBytesFileName = "extracted/MSBytesFromEveryNonce_FullBlockchainChunk1.data" AM_fileName = "extracted/AM_Chunk1.txt" #open files arqLSBytes = open(LSBytesFileName, 'ab') arqBytes1 = open(Bytes1FileName, 'ab') arqBytes2 = open(Bytes2FileName, 'ab') arqMSBytes = open(MSBytesFileName, 'ab') arqArithmeticMean = open(AM_fileName, 'a')