async def challenge(self, body, stream):
challenge = body.get('params', {}).get('token')
signed_challenge = TU.generate_signature(challenge,
self.config.private_key)
await self.write_result(
stream, 'authenticate', {
'peer': self.config.peer.to_dict(),
'signed_challenge': signed_challenge
}, body['id'])
async def challenge(self, body, stream):
self.ensure_protocol_version(body, stream)
params = body.get('params', {})
challenge = params.get('token')
signed_challenge = TU.generate_signature(challenge,
self.config.private_key)
if stream.peer.protocol_version > 1:
await self.write_params(
stream, 'authenticate', {
'peer': self.config.peer.to_dict(),
'signed_challenge': signed_challenge
})
else:
await self.write_result(
stream, 'authenticate', {
'peer': self.config.peer.to_dict(),
'signed_challenge': signed_challenge
}, body['id'])
async def generate(
cls,
transactions=None,
public_key=None,
private_key=None,
force_version=None,
index=0,
force_time=None,
prev_hash=None,
nonce=None,
target=CHAIN.MAX_TARGET
):
config = get_config()
app_log = getLogger("tornado.application")
if force_version is None:
version = CHAIN.get_version_for_height(index)
else:
version = force_version
if force_time:
xtime = str(int(force_time))
else:
xtime = str(int(time.time()))
index = int(index)
if index == 0:
prev_hash = ''
elif prev_hash is None and index != 0:
prev_hash = LatestBlock.block.hash
transactions = transactions or []
transaction_objs = []
fee_sum = 0.0
used_sigs = []
used_inputs = {}
for txn in transactions:
try:
if isinstance(txn, Transaction):
transaction_obj = txn
else:
transaction_obj = Transaction.from_dict(txn)
if transaction_obj.transaction_signature in used_sigs:
print('duplicate transaction found and removed')
continue
await transaction_obj.verify()
used_sigs.append(transaction_obj.transaction_signature)
except:
raise InvalidTransactionException("invalid transactions")
try:
if int(index) > CHAIN.CHECK_TIME_FROM and (int(transaction_obj.time) > int(xtime) + CHAIN.TIME_TOLERANCE):
config.mongo.db.miner_transactions.remove({'id': transaction_obj.transaction_signature}, multi=True)
app_log.debug("Block embeds txn too far in the future {} {}".format(xtime, transaction_obj.time))
continue
if transaction_obj.inputs:
failed = False
used_ids_in_this_txn = []
for x in transaction_obj.inputs:
if config.BU.is_input_spent(x.id, transaction_obj.public_key):
failed = True
if x.id in used_ids_in_this_txn:
failed = True
if (x.id, transaction_obj.public_key) in used_inputs:
failed = True
used_inputs[(x.id, transaction_obj.public_key)] = transaction_obj
used_ids_in_this_txn.append(x.id)
if failed:
continue
transaction_objs.append(transaction_obj)
fee_sum += float(transaction_obj.fee)
except Exception as e:
await config.mongo.async_db.miner_transactions.delete_many({'id': transaction_obj.transaction_signature})
config.app_log.debug('Exception {}'.format(e))
continue
block_reward = CHAIN.get_block_reward(index)
coinbase_txn = await Transaction.generate(
public_key=public_key,
private_key=private_key,
outputs=[{
'value': block_reward + float(fee_sum),
'to': str(P2PKHBitcoinAddress.from_pubkey(bytes.fromhex(public_key)))
}],
coinbase=True
)
transaction_objs.append(coinbase_txn)
transactions = transaction_objs
block = await cls.init_async(
version=version,
block_time=xtime,
block_index=index,
prev_hash=prev_hash,
transactions=transactions,
public_key=public_key,
target=target
)
txn_hashes = block.get_transaction_hashes()
block.set_merkle_root(txn_hashes)
block.target = target
block.header = block.generate_header()
if nonce:
block.nonce = str(nonce)
block.hash = block.generate_hash_from_header(
block.index,
block.header,
str(block.nonce)
)
block.signature = TU.generate_signature(block.hash, private_key)
return block
def generate_transaction_signature(self):
return TU.generate_signature(self.hash, self.private_key)
