def create_gift_coin(self, blockchain): """ This method creates a new coin for the new client """ # Get address of the client hash_public_key = self.hash_pubkey() coin_gift_tx_input = TransactionInput(prev_tx="1" * 64, pk_spender="1" * 64, signature=bytes( "\x11" * 64, encoding="utf-8")) coin_gift_tx_output = TransactionOutput( value=100, hash_pubkey_recipient=hash_public_key) coin_gift_tx = Transaction(tx_input=coin_gift_tx_input, tx_output=coin_gift_tx_output) transactions = [coin_gift_tx] nonce = 0 new_block = None while True: if len(blockchain.blocks) != 0: hash_prev_block = blockchain.blocks[len(blockchain.blocks) - 1].get_hash() new_block = Block(transactions, nonce, hash_prev_block) else: new_block = Block(transactions=transactions, nonce=nonce, prev_block_hash="0" * 64) if new_block.get_hash().startswith("0" * blockchain.difficulty): print("Nonce found:", nonce) break nonce += 1 print(coin_gift_tx.serialize()) message = "\x12" + new_block.serialize() self.socket.sendall(message.encode('utf-8'))
def generate(self): console.info("generating a transaction") tx, src_idx, amount_available = self.find_unspent() src_hash = tx.hash message = src_hash + int_to_bytes(src_idx) signature = self._ecdsa.sign(message) key = self._ecdsa.public_key tx_input = TransactionInput( src_hash=src_hash, src_idx=src_idx, signature=signature, key=key ) amount_send = int(amount_available * random.random()) fee = int((amount_available - amount_send) * random.random()) amount_rest = amount_available - amount_send - fee peers_with_address = self.peers_with_address() # If no known peers, we will send to ourselves receiver_key = self._ecdsa.public_key # Choose coin receiver at random try: receiver = random.choice(peers_with_address) receiver_key = receiver.address except IndexError: pass # Output that transfers `amount_send` coins to the chosen node output_send = TransactionOutput( amount=amount_send, key=receiver_key ) # Output that transfers the rest of the coins back to us. # The coins that are not in outputs constitute the transaction fee # (will be collected by the miner who will incude this transaction into # a new block) output_rest = TransactionOutput( amount=amount_rest, key=self._ecdsa.public_key ) return Transaction( inputs=[tx_input], outputs=[output_send, output_rest] )
def make_next_block(self): if not self.blockchain.blocks: new_block = Block(time.time(), [ Transaction(None, self.address, self.blockchain.mining_reward, 0) ], 'Genesis', 1) else: txs = [] invalid_txs = [] highest_fee_txs = sorted(self.blockchain.mempool, key=lambda x: x.fee, reverse=True) included_amount = {} for tx in highest_fee_txs: if tx.from_address not in included_amount: included_amount[tx.from_address] = 0 if tx.amount + tx.fee <= self.blockchain.get_balance( tx.from_address) - included_amount[tx.from_address]: txs.append(tx) included_amount[tx.from_address] += tx.amount + tx.fee if len(txs) >= self.blockchain.MAX_TX_PER_BLOCK - 1: break else: invalid_txs.append(tx) if invalid_txs: self.blockchain.mempool = [ tx for tx in self.blockchain.mempool if tx not in invalid_txs ] self.blockchain.save_data(self.blockchain.mempool, 'mempool') total_fees = sum([tx.fee for tx in txs]) txs.append( Transaction(None, self.address, self.blockchain.mining_reward + total_fees, 0)) timestamp = time.time() new_block = Block(timestamp, txs, self.blockchain.blocks[-1].hash, self.calculate_difficulty(timestamp)) return new_block
def get_genesis_transaction(sender_wallet, recipient_wallet, value, all_utxos): genesis_transaction = Transaction( sender_wallet.public_key_as_str(), recipient_wallet.public_key_as_str(), value, [] ) genesis_transaction.generate_signature(sender_wallet.private_key) # manually sign genesis transaction genesis_transaction.transaction_id = "0" # manually set transaction id # manually generate transaction output genesis_transaction.outputs.append(TransactionOutput( genesis_transaction.recipient, genesis_transaction.value, genesis_transaction.transaction_id )) # its important to save our first transaction output in utxos all_utxos[genesis_transaction.outputs[0].id] = genesis_transaction.outputs[0] return genesis_transaction
def send_transaction(): params = request.get_json(silent=True) if params: address = params.get('address') amount = params.get('amount') privkey = params.get('privkey') if not privkey or type(privkey) != str or not address or type( address) != str or not amount or (type(amount) != int and type(amount) != float): return json_res(err=1015, message="invalid privkey, address or amount") result = Transaction.send_transaction_by_key(privkey, address, amount) return json_res(result) return json_res(err=1013, message="miss params")
async def transaction(): """HTTP POST endpoint to submit a new transaction to the blockchain.""" new_tx: str = await request.get_json() print( f"New transaction FROM: {new_tx['from']} TO: {new_tx['to']} AMOUNT: {new_tx['amount']}\n" ) #TODO:VALIDATION HERE tran: Transaction = Transaction(str(new_tx['from']), str(new_tx['to']), str(new_tx['amount'])) try: await node.add_transaction(node.broadcast_outbox, tran) except Exception as ex: print("Error '{0}' occured. Arguments {1}.".format(ex, ex.args)) return "OK"
def prepare_chain_for_tests(): pub, prv = cryptutil.fake_new_keys(2048) pub2, prv2 = cryptutil.fake_new_keys(2048) pub_txt = pub.exportKey("PEM").decode('ascii') pub2_txt = pub2.exportKey("PEM").decode('ascii') block_chain.mine_block(pub_txt) block_chain.mine_block(pub2_txt) block_chain.mine_block(pub_txt) trx = Transaction(pub_txt, pub2_txt, 10) trx.sign(prv) block_chain.add_transaction(trx) trx = Transaction(pub_txt, pub2_txt, 10) trx.sign(prv) block_chain.add_transaction(trx) block_chain.mine_block(pub_txt)
def new_transaction(self, transaction): # check if we have enough coins to execute that transaction if not self.address( ) in self.blockchain.balances or self.blockchain.balances[ self.address()] < transaction['amount']: logger.error('You dont have %d!' % transaction['amount']) return False # create the transaction object tx = Transaction(from_pubkey=self.address(), to_pubkey=transaction['to'], amount=transaction['amount']) # sign it with our private key self.sign_transaction(tx) # add it to the transaction pool, waiting to be mined in a block self.transaction_pool.append(tx) logger.info('Transaction %d to %s added to transaction pool!' % (transaction['amount'], transaction['to'])) # done! return True
def add_transaction(): data = request.json transaction = Transaction.from_dict(data) transaction_pool.append(transaction) return jsonify({"status": "OK"})
nodes.append( Malicious(id, create_model(), my_x_train[i], my_new_y_train, my_x_test[i], my_y_test[i], equally_fully_connected(id, ids), policy_update_model_weights_name="equal", policy_update_model_weights_func= my_policy_update_model_weights)) # set blockchain genesis_transaction = Transaction(nodes[0].id, int(time.time()), flmodel=nodes[0].get_model()) # node 0 blockchain = Blockchain( genesis_transaction, policy_update_txs_weight_name="heaviest", policy_update_txs_weight_func=my_policy_update_txs_weight) # blockchain.print() # round # TODO: GPU # TODO: websocket elapsed_times = list() for r in range(num_round): start_time = time.time() print("Round", r)
def coinbase_tx(): coinbase_tx = Transaction.generate_coinbase_transaction( Scorpio.get_pubkey_der(), Scorpio.get_latest_block().index + 1) return json_res(coinbase_tx)
from blockchain import Block, Transaction # SAMPLE BLOCKCHAIN EXAMPLE # Genesis block building genesis_transaction = [] genesis_transaction.append(Transaction('sample.pdf')) genesisBlock = Block(0, genesis_transaction, 1) # Adding blocks with different transcations second_transactions = [] second_transactions.append(Transaction('test.pdf')) second_transactions.append(Transaction('docfile.docx')) second = Block(genesisBlock.get_blockhash(), second_transactions, 1) third_transactions = [] third_transactions.append(Transaction('R1.docx')) third_transactions.append(Transaction('main.py')) third = Block(second.get_blockhash(), third_transactions, 1) print(genesisBlock.get_blockhash()) print(second.get_blockhash()) print(third.get_blockhash())
def parseTransaction(obj): return Transaction.Transaction(obj['index'],obj['price'],obj['landID'],obj['sellerID'],obj['buyerID'],obj['sellSign'],obj['buySign'],obj['documents'])
import random import time from blockchain import Block, Blockchain, Transaction USERS = ['Alice', 'James', 'Smith', 'David', 'Adams', 'Isaac', 'Lewis'] SLEEP_TIME = 0 if __name__ == '__main__': chain = Blockchain() for _ in range(random.randint(1, 5)): block = Block() for _ in range(random.randint(1, 3)): sender, receiver = random.sample(USERS, k=2) transaction = Transaction(sender=sender, receiver=receiver, value=random.randint(10, 100)) block.add_transaction(transaction) time.sleep(SLEEP_TIME) chain.add_block(block) print(chain) time.sleep(SLEEP_TIME)
def run_miner(): """Run the main miner loop. """ global blockchain global public global private new_reward = REWARD while True: # Load transaction queue and blockchain from server. new = [] blockchain = Blockchain() blockchain.add_block( Block( timestamp=datetime.datetime.now(), transactions=[], previous_hash=get_genisis().hash_block(), nonce=12834 ), cheat=True ) server = load_blockchain() txns = load_transactions() # Is this _the_ new block? # or did the server swoop us :( new_chain = load_blockchain() num_blocks = 1333 + server.head.height for i in range (num_blocks): reward = Transaction( id = gen_uuid(), owner = "mined", receiver = public, coins = REWARD, signature = None ) reward.signature = sign(reward.comp(), private) txns = [reward] b = Block( timestamp = datetime.datetime.now(), transactions = txns, previous_hash = blockchain.head.hash_block() ) blockchain.add_block(b, cheat=True) # Let's mine this block. reward = Transaction( id = gen_uuid(), owner = "mined", receiver = public, coins = REWARD, signature = None ) reward.signature = sign(reward.comp(), private) txns = [reward] # Construct a new block. b = Block( timestamp = datetime.datetime.now(), transactions = txns, previous_hash = b.hash_block() ) print(blockchain.head.height) mine_till_found(b) # WE MINED THIS BLOCK YAY. # AND WE WIN. resp = get_route('add', data=str(b)) if resp['success']: print "Block added!" delete_queue(txns) else: print "Couldn't add block:", resp['message']
from ecdsa import SECP256k1, SigningKey from blockchain import Blockchain, Transaction if __name__ == "__main__": if len(sys.argv) == 1: raise Exception("Missing private key!") private_key = sys.argv[1] my_sk = SigningKey.from_string( bytes.fromhex(private_key), curve=SECP256k1, ) my_vk = my_sk.verifying_key.to_string().hex() cycoin = Blockchain() tx_1 = Transaction(my_vk, "public key goes here", 10) tx_1.sign_transaction(my_sk) cycoin.add_transaction(tx_1) print("START MINING") cycoin.mine_pending_transactions(my_vk) print("DONE MINING") print("my balance: ", cycoin.get_balance_of_address(my_vk)) cycoin.print_chain()
def mine_block(self): # if no blocks, create the genesis block if len(self.blockchain.blocks) == 0: self.blockchain.create_genesis_block() logger.info('Genesis block created!') return True else: # calculate what the next diffculty should be new_block_difficulty = self.blockchain.compute_next_difficulty() # add all transactions from the transaction pool to this block tx_list = [] for tx in self.transaction_pool: tx_list.append(tx) # create the block block_candidate = Block() # set the new blocks fields based on current blockchain block_candidate.fill_block( height=self.blockchain.get_last_block().height + 1, difficulty=new_block_difficulty, previous_hash=self.blockchain.get_last_block().hash, transactions=tx_list, timestamp=time.time()) # create the coinbase transaction, awards BLOCK_REWARD coins to ourselves (the miner) coinbase_tx = Transaction(from_pubkey='COINBASE', to_pubkey=self.address(), amount=BLOCK_REWARD) # sign the coinbase transaction self.sign_transaction(coinbase_tx) # add it to the list of transactions for this block block_candidate.transactions.append(coinbase_tx) logger.info('Mining block %d ... [difficulty=%d] [target=%s]' % (block_candidate.height, block_candidate.difficulty, block_candidate.difficulty_to_target())) # find the correct nonce for this block, this takes a while to calculate, hopefully BLOCK_TIME_IN_SECONDS self.find_nonce(block_candidate) # if find_nonce terminated because we received a new block discard the block if self.new_block_received: logger.info('Skipped block %d' % block_candidate.height) # reset the flag self.new_block_received = False # well, we did not mine anything return False else: # try adding the block to our current blockchain using add_block if not self.blockchain.add_block(block_candidate): # add_block failed! something was not right in the new block logger.error('Mined block %d discarded!' % block_candidate.height) return False else: # clear the transaction pool. Those transactions are now safely in a block in the blockchain self.transaction_pool = [] logger.info('Block %d mined!' % block_candidate.height) # mining successful! return True
def setUp(self): t0 = Transaction(0, "hello world") t1 = Transaction(t0.hash, "woe is me") t2 = Transaction(t1.hash, "woe is me") self.b0 = Block(0, 0, t0, t1) self.b1 = Block(0, self.b0.hash, t2)
def setUp(self): self.t0 = Transaction(0, "hello world") self.t1 = Transaction(self.t0.hash, "woe is me")
my_blockchain = Blockchain(3, 'MaciekCoins') maciek = User('maciek') maciek.export_keys() jurek = User('jurek') my_blockchain.user_amount(maciek) my_blockchain.user_amount(jurek) print('\n\n___________________Mining________________\n') my_blockchain.mine_coin(1000, maciek) my_blockchain.user_amount(maciek) my_blockchain.user_amount(jurek) print('\n\n___________________Valid transaction________________\n') transaction1 = Transaction(maciek, jurek, 100, 1) transaction2 = Transaction(maciek, jurek, 100, 2) transaction1.print_trans() transaction2.print_trans() block = [ transaction1.get_signed_transaction(), transaction2.get_signed_transaction() ] my_blockchain.try_add_block(block) my_blockchain.user_amount(maciek) my_blockchain.user_amount(jurek) transaction1 = Transaction(jurek, maciek, 200, 1)
def new_transaction(self, recipient, amount): """Send an amount of coins to a recipient""" self.consensus() if recipient not in [x.name for x in self.friends]: self.log("I don't know {}".format(recipient)) return False if amount > self.balance: self.log("I don't have enough money to send {} {} Coins.".format( recipient, amount)) return False self.log("I'm sending {} {} Coins.".format(recipient, amount)) outputs = [] spent_outputs = [] for block in self.blockchain.ledger: for output in block.transaction.outputs: # Sum all earnings if output["public_key"] == self.public_key: outputs.append((block.transaction.hash, block.transaction.outputs.index(output))) for input in block.transaction.inputs: # Detect outgoings if input["public_key"] == self.public_key: spent_outputs.append( (input["hash"], input["output_index"])) outputs_for_t_input = [] for output in outputs: if output not in spent_outputs: outputs_for_t_input.append(output) outputs = outputs_for_t_input output_amount = 0 for b in self.blockchain.ledger: for output in outputs: if b.transaction.hash == output[0]: output_amount += b.transaction.outputs[output[1]]["amount"] for friend in self.friends: if friend.name == recipient: recipient = friend.public_key inputs = [] for output in outputs: # Generate inputs sig = self.private_key.sign(output[0].encode()) inputs.append({ "hash": output[0], "output_index": output[1], "signature": sig, "public_key": self.public_key }) outputs = [{"public_key": recipient, "amount": amount}] if amount < output_amount: outputs.append({ "public_key": self.public_key, "amount": output_amount - amount }) transaction = Transaction(inputs=inputs.copy(), outputs=outputs.copy()) self.unverified_transactions_pool.append(transaction)
time.sleep(0.3) def run(self): self.thread = threading.Thread(target=self.scan_tx) self.thread.start() def stop(self): self.stop_flag = True self.thread.join() if __name__ == '__main__': node = Node() node.run() print("input (file name or stop):") while True: input_str = input() if input_str == "stop": node.stop() break txs = read_from_file(input_str) for tx in txs: from_adress, to_address, amount = tx from_account = node.blockchain.state.get_account(from_adress) raw_tx = Transaction(from_adress, to_address, amount) node.blockchain.tx_pool.append(raw_tx)
def __init__(self, address): """ Initialization method for Client class Convention: 0x10 - New Transaction 0x11 - New peers 0x12 - New mined block 0x13 - Blockchain """ self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Make the connection self.socket.connect((address, 5000)) self.byte_size = 1024 self.peers = [] print('==> Connected to server.') self.generate_key_pair() client_listener_thread = threading.Thread(target=self.send_message) client_listener_thread.start() while True: try: data = self.receive_message() if data[0:1] == '\x11': print('==> Got peers.') update_peers(data[1:]) elif data[0:1] == '\x10': print('==> New transaction.') transaction_info = data[1:] transaction = Transaction(serialization=transaction_info) # Mining block result = mine_block(transaction=transaction, blockchain=self.blockchain, miner_address=self.hash_pubkey()) if result["status"]: message = "\x12" + result["new_block"].serialize() print("==> Sending new mined block") self.socket.sendall(message.encode("utf-8")) else: print( "==> Invalid transaction. The block have not been mined" ) elif data[0:1] == '\x13': print('==> Blockchain downloaded.') blockchain_info = data[1:] self.blockchain = Blockchain(serialization=blockchain_info) update_blockchain_file(self.blockchain.serialize()) elif data[0:1] == '\x12': print('==> New mined block.') block_info = data[1:] new_block = Block(serialization=block_info) in_blockchain = False for block in self.blockchain.blocks: if new_block.equal_blocks(block): print( "==> This block is already mined and is in your blockchain. It will not be added" ) in_blockchain = True break if not in_blockchain: print("\t", new_block.__dict__) print("\tNew Block Hash:", new_block.get_hash()) self.blockchain.add_block(new_block) update_blockchain_file(self.blockchain.serialize()) elif data != "": print("[#] " + data) except ConnectionError as error: print("==> Server disconnected. ") print('\t--' + str(error)) break
json.dump({ "public": wallets[0][1], "private": wallets[0][0] }, open("walletA.json", "w")) json.dump({ "public": wallets[1][1], "private": wallets[1][0] }, open("walletB.json", "w")) print(repr(wallets)) blocksToSubmit = [] #mine initial block reward = Transaction(id=gen_uuid(), owner="mined", receiver=wallets[0][1], coins=REWARD, signature="") lastBlock = construct_and_mine([reward], get_genisis()) blocksToSubmit.append(lastBlock) balances = (10, 0) for i in range(ITERS): weight = randint(10, 20) txns = [ paySomeone(wallets[0][1], wallets[0][0], wallets[1][1], balances[0]) for _ in range(weight) ] lastBlock = construct_and_mine(txns, lastBlock) blocksToSubmit.append(lastBlock)
from fastecdsa import curve, ecdsa, keys # Your private key goes here priv_key = keys.gen_private_key(curve.secp256k1) # From that we can calculate your public key(which doubles as your wallet address) pub_key = keys.get_public_key(priv_key, curve.secp256k1) myWalletAddress = hex(int(str(pub_key.x) + str(pub_key.y))) # Create new instance of Blockchain class print('Initialize coin') rebelCoin = Blockchain() # Create a transaction & sign it with your key print('1st trans') tx1 = Transaction(myWalletAddress, '123456789', 100) tx1.signTransaction(priv_key) # These try/except blocks are neccessary for now due to a bug i have where # there's either an ecdsa error or a key error, but reruning fixes it try: try: rebelCoin.addTransaction(tx1) except ecdsa.EcdsaError: rebelCoin.addTransaction(tx1) except: rebelCoin.addTransaction(tx1) print() # Mine block rebelCoin.minePendingTransactions(myWalletAddress)
def test_post_block(self): t0 = Transaction(0, "Foo") block = Block(0, self.chain.chain[-1].hash, t0) self.chain.add(block) response = requests.post('http://localhost:5000/block', data=block.serialize())
def run_miner(): """Run the main miner loop. """ my_address = "2cb4fc5902917e58e531cfbe1d909727aaf331b4856bf8627e09bf8941b69a40" my_private = "610af1630bf08b0072d97bdaf71882cd0a2c86e7af72296b4ee73f508b812c28" my_address_2 = "a173fd8d2330cc2b4776730891f50099204376217c67b7b23254aca04fbeb5a3" my_private_2 = "d0f783f01ac0df1799856964fe74f702763932e1edf3e9d0074646de885d5559" public = my_address_2 private = my_private_2 donor = None while True: print("new public", public) print("new private", private) global blockchain global real_b1 global fake_b1 global fake_b2 blockchain = load_blockchain() # Add reward to us yay. # my_address_3 = "5adbd7137903135fa2cc5a2de2035a326319e42188a9c6714b26fa016c6ac1bb" # my_private_3 = "91f233e1218135b772ddc87a199e6d3cc18233753623f95385dde62e886304c7" amount_1 = blockchain.get_wallet_amount(my_address) amount_2 = blockchain.get_wallet_amount(my_address_2) # amount_3 = blockchain.get_wallet_amount(my_address_3) if amount_1 < 0: my_private, my_address = generate_keys() public = my_address private = my_private donor_pub = my_address_2 donor_private = my_private_2 donor_amount = amount_2 else: my_private_2, my_address_2 = generate_keys() public = my_address_2 private = my_private_2 donor_pub = my_address donor_private = my_private donor_amount = amount_1 # Add reward to us yay. reward = Transaction( id = gen_uuid(), owner = "mined", receiver = public, coins = REWARD, signature = None ) txns = [] reward.signature = sign(reward.comp(), private) txns.append(reward) donation1 = Transaction( id = gen_uuid(), owner = donor_pub, receiver = "3119281c76dc54009925c9208bedc5bd0162c27034a1649fd7e2e5df62dba557", coins = donor_amount, signature = None ) donation1.signature = sign(donation1.comp(), donor_private) donation2 = Transaction( id = gen_uuid(), owner = donor_pub, receiver = public, coins = donor_amount, signature = None ) donation2.signature = sign(donation2.comp(), donor_private) txns.append(donation1) txns.append(donation2) # Construct a new block. real_b1 = Block( timestamp = datetime.datetime.now(), transactions = txns, previous_hash = blockchain.head.hash_block() ) mine_till_found(real_b1) new_chain = load_blockchain() # print "Adding real block now" # resp1 = get_route('add', data=str(real_b1)) # if resp1['success']: # print "Added real block1!" # else: # print "Couldn't add block:", resp1['message'] if new_chain.head.hash_block() == blockchain.head.hash_block(): print "Adding real block now" resp1 = get_route('add', data=str(real_b1)) if resp1['success']: print "Added real block1!" else: print "Couldn't add block:", resp1['message'] else: print "Someone else mined the block before us :("
def add_transaction(): data = request.get_json() transaction = Transaction(**data) node.add_unconfirmed_txn(transaction.__dict__) return "transaction received", 200
from blockchain import BlockChain, Transaction, Wallet from blockchain import generate_genesis if __name__ == '__main__': blockchain, satoshi = generate_genesis() transaction1 = Transaction(satoshi.private_key, satoshi.public_key, 10, 0.80) transaction2 = Transaction(satoshi.private_key, satoshi.public_key, 20, 0.90) blockchain.add_transacction(transaction1) blockchain.add_transacction(transaction2) block = blockchain.mine() print("Hash : " + block.hash) print("Reward : " + str(block.reward))
def run_miner(): """Run the main miner loop. """ global blockchain global public global private while True: # Load transaction queue and blockchain from server. txns = load_transactions() blockchain = load_blockchain() # Loc: Check our balance balance = get_balance(public) print "Current balance", balance # Loc: Set up attack is_attacking = False if balance > 60: print "Setting up Finney attack" is_attacking = True t = Transaction( id=gen_uuid(), owner=public, receiver= "6f181e44edfc93de084071e590421e5b083f93da6012d441658b6b31a966ae9c", coins=balance, signature=None) # Sign it. t.signature = sign(t.comp(), private) # Pay myself a lot! for x in range(0, 3): txns.append(t) # Add reward to us yay. reward = Transaction(id=gen_uuid(), owner="mined", receiver=public, coins=REWARD, signature=None) reward.signature = sign(reward.comp(), private) txns.append(reward) # Construct a new block. b = Block(timestamp=datetime.datetime.now(), transactions=txns, previous_hash=blockchain.head.hash_block()) # Let's mine this block. mine_till_found(b) # Is this _the_ new block? # or did the server swoop us :( new_chain = load_blockchain() if new_chain.head.hash_block() == blockchain.head.hash_block(): # WE MINED THIS BLOCK YAY. # AND WE WIN. # Loc: Add in a Finney attack to double spend the coin resp = get_route('add', data=str(b)) if resp['success']: print "Block added!" delete_queue(txns) else: print "Couldn't add block:", resp['message'] else: print "Someone else mined the block before us :("