def pre_pos_1(self, data=None): # triggered after genesis for block 1..
logger.info('pre_pos_1')
# are we a staker in the stake list?
if self.chain.mining_address not in self.chain.m_blockchain[0].stake_list:
logger.info('not in stake list..no further pre_pos_x calls')
return
logger.info('mining address: %s in the genesis.stake_list', self.chain.mining_address)
xmss = self.chain.wallet.address_bundle[0].xmss
tmphc = hashchain(xmss.get_seed_private(), epoch=0)
self.chain.hash_chain = tmphc.hashchain
self.chain.block_chain_buffer.hash_chain[0] = tmphc.hashchain
tmpbalance = self.chain.state.state_balance(self.chain.mining_address)
slave_xmss = self.chain.block_chain_buffer.get_slave_xmss(0)
if not slave_xmss:
logger.info('Waiting for SLAVE XMSS to be done')
reactor.callLater(5, self.pre_pos_1)
return
st = StakeTransaction().create(blocknumber=0,
xmss=self.chain.wallet.address_bundle[0].xmss,
slave_public_key=slave_xmss.pk(),
hashchain_terminator=tmphc.hc_terminator,
first_hash=tmphc.hashchain[-1][-2],
balance=tmpbalance)
self.chain.add_tx_to_pool(st)
# send the stake tx to generate hashchain terminators for the staker addresses..
self.p2pFactory.send_st_to_peers(st)
logger.info('await delayed call to build staker list from genesis')
reactor.callLater(5, self.pre_pos_2, st)
def make_st_tx(self, blocknumber, first_hash):
balance = self.chain.block_chain_buffer.get_stxn_state(blocknumber, self.chain.mining_address)[1]
if balance < config.dev.minimum_staking_balance_required:
logger.warning('Staking not allowed due to insufficient balance')
logger.warning('Balance %s', balance)
return
slave_xmss = self.chain.block_chain_buffer.get_next_slave_xmss(blocknumber)
if not slave_xmss:
return
st = StakeTransaction().create(
blocknumber=blocknumber,
xmss=self.chain.wallet.address_bundle[0].xmss,
slave_public_key=slave_xmss.pk(),
first_hash=first_hash,
balance=balance
)
self.p2pFactory.send_st_to_peers(st)
for num in range(len(self.chain.transaction_pool)):
t = self.chain.transaction_pool[num]
if t.subtype == qrl.core.Transaction_subtypes.TX_SUBTYPE_STAKE and st.hash == t.hash:
if st.get_message_hash() == t.get_message_hash():
return
self.chain.remove_tx_from_pool(t)
break
self.chain.add_tx_to_pool(st)
self.chain.wallet.save_wallet()
def ST(self, data):
"""
Stake Transaction
This function processes whenever a Transaction having
subtype ST is received.
:return:
"""
try:
st = StakeTransaction().json_to_transaction(data)
except Exception as e:
logger.error(
'st rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
self.transport.loseConnection()
return
if not self.factory.master_mr.isRequested(st.get_message_hash(), self):
return
if len(
self.factory.chain.m_blockchain
) == 1 and st.epoch > 0: # catch error for new nodes listening for ST's from later epochs
return
for t in self.factory.chain.transaction_pool:
if st.get_message_hash() == t.get_message_hash():
return
tx_state = self.factory.chain.block_chain_buffer.get_stxn_state(
blocknumber=self.factory.chain.block_chain_buffer.height() + 1,
addr=st.txfrom)
if st.validate_tx() and st.state_validate_tx(tx_state=tx_state):
self.factory.chain.add_tx_to_pool(st)
else:
hashes = []
for item in st.hash:
hashes.append(bin2hstr(item))
logger.warning('>>>ST %s invalid state validation failed..',
hashes)
return
self.factory.register_and_broadcast('ST', st.get_message_hash(),
st.transaction_to_json())
return