def on_newtransaction(self, data): #print("new transaction ", data) config = app.config['yada_config'] mongo = app.config['yada_mongo'] try: incoming_txn = Transaction.from_dict( config, mongo, BU.get_latest_block(config, mongo)['index'], data) except Exception as e: print "transaction is bad" print e raise Exception("transaction is bad") except BaseException as e: print "transaction is bad" print e raise Exception("transaction is bad") try: print incoming_txn.transaction_signature dup_check = mongo.db.miner_transactions.find( {'id': incoming_txn.transaction_signature}) if dup_check.count(): print 'found duplicate' raise Exception("duplicate") mongo.db.miner_transactions.update(incoming_txn.to_dict(), incoming_txn.to_dict(), upsert=True) except Exception as e: print e raise Exception("transaction is bad") except BaseException as e: print e raise Exception("transaction is bad")
def new_block_checker(current_index): while 1: try: current_index.value = BU.get_latest_block().get('index') except: pass time.sleep(1)
def nonce_generator(): Mongo.init() latest_block_index = BU.get_latest_block()['index'] while 1: next_latest_block_index = BU.get_latest_block()['index'] if latest_block_index < next_latest_block_index: print '\r\nMining block height:', next_latest_block_index latest_block_index = next_latest_block_index start_nonce = 0 else: try: start_nonce += 1000000 except: print '\r\nMining block height:', latest_block_index start_nonce = 0 yield [start_nonce, start_nonce + 1000000]
def dispatch_request(self): config = app.config['yada_config'] mongo = app.config['yada_mongo'] if request.method == 'POST': items = request.json if not isinstance(items, list): items = [ items, ] else: items = [item for item in items] transactions = [] for txn in items: transaction = Transaction.from_dict( config, mongo, BU.get_latest_block(config, mongo)['index'], txn) try: transaction.verify() except InvalidTransactionException: mongo.db.failed_transactions.insert({ 'exception': 'InvalidTransactionException', 'txn': txn }) print 'InvalidTransactionException' return 'InvalidTransactionException', 400 except InvalidTransactionSignatureException: print 'InvalidTransactionSignatureException' mongo.db.failed_transactions.insert({ 'exception': 'InvalidTransactionSignatureException', 'txn': txn }) return 'InvalidTransactionSignatureException', 400 except MissingInputTransactionException: pass except: raise print 'uknown error' return 'uknown error', 400 transactions.append(transaction) for x in transactions: mongo.db.miner_transactions.insert(x.to_dict()) job = Process(target=TxnBroadcaster.txn_broadcast_job, args=(transaction, )) job.start() return json.dumps(request.get_json()) else: rid = request.args.get('rid') if rid: transactions = BU.get_transactions_by_rid( config, mongo, rid, config.bulletin_secret, rid=True, raw=True) else: transactions = [] return json.dumps([x for x in transactions])
def __init__(self): Mongo.init() latest_block = BU.get_latest_block() if latest_block: self.latest_block = Block.from_dict(latest_block) else: self.insert_genesis() self.verify_existing_blockchain()
def post_block(): block = Block.from_dict(request.json) block.verify() my_latest_block = BU.get_latest_block() if my_latest_block[0].get('index') - block.index == 1: block.save() return '{"status": "ok"}' else: return '{"status": "error"}', 400
def dispatch_request(self): config = app.config['yada_config'] mongo = app.config['yada_mongo'] unspent = BU.get_wallet_unspent_transactions( config, mongo, request.json.get('address')) unspent_inputs = dict([(x['id'], x) for x in unspent]) input_sum = 0 for x in request.json.get('inputs'): found = False if x['id'] in unspent_inputs: for tx in unspent_inputs[x['id']].get('outputs'): input_sum += float(tx['value']) found = True break if not found: if mongo.db.blocks.find_one({'transactions.id': x['id']}, {'_id': 0}): return json.dumps({ 'status': 'error', 'msg': 'output already spent' }), 400 else: return json.dumps({ 'status': 'error', 'msg': 'transaction id not in blockchain' }), 400 output_sum = 0 for x in request.json.get('outputs'): output_sum += float(x['value']) if (output_sum + float(request.json.get('fee'))) > input_sum: return json.dumps({ 'status': 'error', 'msg': 'not enough inputs to pay for transaction outputs + fee' }) try: txn = TransactionFactory(config, mongo, block_height=BU.get_latest_block( config, mongo)['index'], public_key=request.json.get('public_key'), fee=float(request.json.get('fee')), inputs=request.json.get('inputs'), outputs=request.json.get('outputs')) except NotEnoughMoneyException as e: return json.dumps({ 'status': 'error', 'msg': 'not enough coins from referenced inputs to pay for transaction outputs + fee' }), 400 return '{"header": "%s", "hash": "%s"}' % (txn.header, txn.hash)
def generate_some_blocks(keys): for key in keys: transactions = [] existing_input = mongo.db.blocks.find({'transactions.outputs.to': key.get('address')}) if existing_input.count() == 0: config = Wallet(key) index = BU.get_latest_block(config, mongo)['index'] + 1 block = BlockFactory(transactions, key.get('public_key'), key.get('private_key'), index=index) block.block.special_min = True block.block.target = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff block.block.nonce = 0 header = BlockFactory.generate_header(block.block) block.block.hash = BlockFactory.generate_hash_from_header(header, block.block.nonce) block.block.signature = BU.generate_signature(block.block.hash, key['private_key']) mongo.db.consensus.insert({ 'peer': 'me', 'index': block.block.index, 'id': block.block.signature, 'block': block.block.to_dict() }) consensus.sync_bottom_up()
def sync(self): #top down syncing self.latest_block = Block.from_dict(BU.get_latest_block()) self.remove_pending_transactions_now_in_chain() latest_consensus = self.get_latest_consensus_block() if latest_consensus: print latest_consensus.index, "latest consensus_block" # check for difference between blockchain and consensus table heights if self.latest_block.index == latest_consensus.index: self.log('up to date, height: ' + str(latest_consensus.index)) return records = Mongo.db.consensus.find({ 'index': latest_consensus.index, 'block.version': BU.get_version_for_height(latest_consensus.index) }) for record in sorted(records, key=lambda x: int(x['block']['target'], 16)): block = Block.from_dict(record['block']) peer = Peer.from_string(record['peer']) print self.latest_block.hash, block.prev_hash, self.latest_block.index, ( block.index - 1) try: self.integrate_block_with_existing_chain( block, peer, self.existing_blockchain) except AboveTargetException as e: pass except ForkException as e: self.retrace(block, peer) except IndexError as e: self.retrace(block, peer) else: self.log('no consensus data... none.') return
def node(nonces=None, config=None): Config.from_dict(json.loads(config)) Peers.init() latest_block_index = Value('i', 0) my_peer = Config.peer_host + ":" + str(Config.peer_port) Config.max_duration = 300000 Config.block_version = 1 #p = Process(target=new_block_checker, args=(latest_block_index,)) status = Array('c', 'asldkjf') #p.start() Mongo.init() # default run state will be to mine some blocks! block = BU.get_latest_block() if block: latest_block_index.value = block.get('index') + 1 else: genesis_block = BlockFactory.get_genesis_block() genesis_block.save() Mongo.db.consensus.insert({ 'block': genesis_block.to_dict(), 'peer': 'me', 'id': genesis_block.signature, 'index': 0 }) block = BU.get_latest_block() latest_block_index.value = block.get('index') dup_test = Mongo.db.consensus.find({ 'peer': 'me', 'index': latest_block_index.value, 'block.version': BU.get_version_for_height(latest_block_index.value + 1) }).sort([('index', -1)]) if dup_test.count(): #print 'returning', latest_block_index.value + 1, BU.get_version_for_height(latest_block_index.value + 1) return transactions = Mongo.db.miner_transactions.find() transaction_objs = [] unspent_indexed = {} for txn in transactions: try: transaction = Transaction.from_dict(txn) transaction.verify() #check double spend address = str( P2PKHBitcoinAddress.from_pubkey( transaction.public_key.decode('hex'))) if address in unspent_indexed: unspent_ids = unspent_indexed[address] else: needed_value = sum( [float(x.value) for x in transaction.outputs]) + float(transaction.fee) res = BU.get_wallet_unspent_transactions( address, needed_value=needed_value) unspent_ids = [x['id'] for x in res] unspent_indexed[address] = unspent_ids failed1 = False failed2 = False used_ids_in_this_txn = [] for x in transaction.inputs: if x.id not in unspent_ids: failed1 = True if x.id in used_ids_in_this_txn: failed2 = True used_ids_in_this_txn.append(x.id) if failed1: Mongo.db.miner_transactions.remove( {'id': transaction.transaction_signature}) print 'transaction removed: input presumably spent already, not in unspent outputs', transaction.transaction_signature Mongo.db.failed_transactions.insert({ 'reason': 'input presumably spent already', 'txn': transaction.to_dict() }) elif failed2: Mongo.db.miner_transactions.remove( {'id': transaction.transaction_signature}) print 'transaction removed: using an input used by another transaction in this block', transaction.transaction_signature Mongo.db.failed_transactions.insert({ 'reason': 'using an input used by another transaction in this block', 'txn': transaction.to_dict() }) else: transaction_objs.append(transaction) except MissingInputTransactionException as e: #print 'missing this input transaction, will try again later' pass except InvalidTransactionSignatureException as e: print 'InvalidTransactionSignatureException: transaction removed' Mongo.db.miner_transactions.remove( {'id': transaction.transaction_signature}) Mongo.db.failed_transactions.insert({ 'reason': 'InvalidTransactionSignatureException', 'txn': transaction.to_dict() }) except InvalidTransactionException as e: print 'InvalidTransactionException: transaction removed' Mongo.db.miner_transactions.remove( {'id': transaction.transaction_signature}) Mongo.db.failed_transactions.insert({ 'reason': 'InvalidTransactionException', 'txn': transaction.to_dict() }) except Exception as e: #print e #print 'rejected transaction', txn['id'] pass except BaseException as e: #print e #print 'rejected transaction', txn['id'] pass try: block = BlockFactory.mine(transaction_objs, Config.public_key, Config.private_key, Config.max_duration, output, latest_block_index, status, nonces) except Exception as e: raise if block: dup_test = Mongo.db.consensus.find_one({ 'peer': 'me', 'index': block.index, 'block.version': BU.get_version_for_height(block.index) }) if not dup_test: print '\r\nCandidate submitted for index:', block.index print '\r\nTransactions:' for x in block.transactions: print x.transaction_signature Mongo.db.consensus.insert({ 'peer': 'me', 'index': block.index, 'id': block.signature, 'block': block.to_dict() }) print '\r\nSent block to:' for peer in Peers.peers: try: block_dict = block.to_dict() block_dict['peer'] = my_peer requests.post('http://{peer}/newblock'.format( peer=peer.host + ":" + str(peer.port)), json=block_dict, timeout=3, headers={'Connection': 'close'}) print peer.host + ":" + str(peer.port) except Exception as e: print e try: print 'reporting bad peer' requests.post('https://yadacoin.io/peers', json={ 'host': peer.host, 'port': str(peer.port), 'failed': True }, timeout=3, headers={'Connection': 'close'}) except: print 'failed to report bad peer' pass
def dispatch_request(self): return json.dumps({ 'block_height': BU.get_latest_block(app.config['yada_config'], app.config['yada_mongo']).get('index') })
def dispatch_request(self): config = app.config['yada_config'] mongo = app.config['yada_mongo'] if request.method == 'GET': bulletin_secret = request.args.get('bulletin_secret', '') username = request.args.get('username', '') to = request.args.get('to', '') else: bulletin_secret = request.json.get('bulletin_secret', '') username = request.json.get('username', '') to = request.json.get('to', '') if not bulletin_secret: return 'error: "bulletin_secret" missing', 400 if not username: return 'error: "username" missing', 400 if not to: return 'error: "to" missing', 400 rid = TU.generate_rid(config, bulletin_secret) dup = mongo.db.blocks.find({'transactions.rid': rid}) if dup.count(): for txn in dup: if txn['public_key'] == config.public_key: return json.dumps({ "success": False, "status": "Already added" }) miner_transactions = mongo.db.miner_transactions.find() mtxn_ids = [] for mtxn in miner_transactions: for mtxninput in mtxn['inputs']: mtxn_ids.append(mtxninput['id']) checked_out_txn_ids = mongo.db.checked_out_txn_ids.find() for mtxn in checked_out_txn_ids: mtxn_ids.append(mtxn['id']) a = os.urandom(32) dh_public_key = scalarmult_base(a).encode('hex') dh_private_key = a.encode('hex') transaction = TransactionFactory(config=config, mongo=mongo, block_height=BU.get_latest_block( config, mongo)['index'], bulletin_secret=bulletin_secret, username=username, fee=0.00, public_key=config.public_key, dh_public_key=dh_public_key, private_key=config.private_key, dh_private_key=dh_private_key, outputs=[{ 'to': to, 'value': 0 }]) TU.save(config, mongo, transaction.transaction) mongo.db.miner_transactions.insert(transaction.transaction.to_dict()) job = Process(target=TxnBroadcaster.txn_broadcast_job, args=(transaction.transaction, )) job.start() my_bulletin_secret = config.bulletin_secret bulletin_secrets = sorted( [str(my_bulletin_secret), str(bulletin_secret)], key=str.lower) rid = hashlib.sha256( str(bulletin_secrets[0]) + str(bulletin_secrets[1])).digest().encode('hex') mongo.site_db.friends.insert({ 'rid': rid, 'relationship': { 'bulletin_secret': bulletin_secret } }) return json.dumps({"success": True})
def dispatch_request(self): config = app.config['yada_config'] mongo = app.config['yada_mongo'] block = BU.get_latest_block(config, mongo) return json.dumps(self.changetime(block), indent=4)
picked = [] picked_sum = 0 for inp in inputs: picked.append(inp) picked_sum += inp['value'] if picked_sum >= float(args.value): break print("picked {:,} inputs totaling {:,} to send for tx" .format(len(inputs), spendable)) # this transaction = Transaction( block_height=BU.get_latest_block(config, mongo)['index'], fee=0.01, public_key=config.public_key, outputs=[ {'to': config.address, 'value': float(args.value)} ], inputs=picked, ) transaction.hash = transaction.generate_hash() transaction.transaction_signature = TU.generate_signature(transaction.hash, config.private_key) transaction.verify() index = BU.get_latest_block(config, mongo)['index'] + 1 block = BlockFactory([transaction], config.public_key, config.private_key, index=index) block.block.special_min = True block.block.target = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff block.block.nonce = 0
def app_getblockheight(): return json.dumps( {'block_height': BU.get_latest_block().get('index')})
def get_latest_block(): block = BU.get_latest_block() return json.dumps(block, indent=4)