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 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 dispatch_request(self):
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(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()
if Config.fcm_key:
for txn in transactions:
job = Process(
target=self.do_push,
args=(txn.to_dict(), request.args.get('bulletin_secret'))
)
job.start()
return json.dumps(request.get_json())
else:
rid = request.args.get('rid')
if rid:
transactions = BU.get_transactions_by_rid(rid, rid=True, raw=True)
else:
transactions = []
return json.dumps([x for x in transactions])
def newtransaction(sid, data):
#print("new transaction ", data)
try:
incoming_txn = Transaction.from_dict(data)
except Exception as e:
print "transaction is bad"
print e
except BaseException as e:
print "transaction is bad"
print e
try:
dup_check = Mongo.db.miner_transactions.find(
{'id': incoming_txn.transaction_signature})
if dup_check.count():
print 'found duplicate'
return
Mongo.db.miner_transactions.update(incoming_txn.to_dict(),
incoming_txn.to_dict(),
upsert=True)
except Exception as e:
print e
except BaseException as e:
print e
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
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
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, config.private_key)