def create_block(self, last_block, mining_nonce, tx_pool: TransactionPool,
miner_address) -> Optional[Block]:
dummy_block = Block.create(block_number=last_block.block_number + 1,
prev_headerhash=last_block.headerhash,
prev_timestamp=last_block.timestamp,
transactions=[],
miner_address=miner_address)
dummy_block.set_nonces(mining_nonce, 0)
t_pool2 = tx_pool.transactions
addresses_set = set()
for tx_set in t_pool2:
tx = tx_set[1].transaction
tx.set_affected_address(addresses_set)
addresses_state = dict()
for address in addresses_set:
addresses_state[address] = self._chain_manager.get_address_state(
address)
block_size = dummy_block.size
block_size_limit = self._chain_manager.get_block_size_limit(last_block)
transactions = []
for tx_set in t_pool2:
tx = tx_set[1].transaction
# Skip Transactions for later, which doesn't fit into block
if block_size + tx.size + config.dev.tx_extra_overhead > block_size_limit:
continue
addr_from_pk_state = addresses_state[tx.addr_from]
addr_from_pk = Transaction.get_slave(tx)
if addr_from_pk:
addr_from_pk_state = addresses_state[addr_from_pk]
if not tx.validate_extended(addresses_state[tx.addr_from],
addr_from_pk_state):
logger.warning('Txn validation failed for tx in tx_pool')
tx_pool.remove_tx_from_pool(tx)
continue
tx.apply_state_changes(addresses_state)
tx._data.nonce = addr_from_pk_state.nonce
block_size += tx.size + config.dev.tx_extra_overhead
transactions.append(tx)
block = Block.create(block_number=last_block.block_number + 1,
prev_headerhash=last_block.headerhash,
prev_timestamp=last_block.timestamp,
transactions=transactions,
miner_address=miner_address)
return block
def apply_state_changes(self, address_txn) -> bool:
coinbase_tx = Transaction.from_pbdata(self.transactions[0])
if not coinbase_tx.validate_extended(self.block_number):
logger.warning('Coinbase transaction failed')
return False
coinbase_tx.apply_state_changes(address_txn)
len_transactions = len(self.transactions)
for tx_idx in range(1, len_transactions):
tx = Transaction.from_pbdata(self.transactions[tx_idx])
if isinstance(tx, CoinBase):
logger.warning('Found another coinbase transaction')
return False
if not tx.validate():
return False
addr_from_pk_state = address_txn[tx.addr_from]
addr_from_pk = Transaction.get_slave(tx)
if addr_from_pk:
addr_from_pk_state = address_txn[addr_from_pk]
if not tx.validate_extended(address_txn[tx.addr_from],
addr_from_pk_state):
return False
expected_nonce = addr_from_pk_state.nonce + 1
if tx.nonce != expected_nonce:
logger.warning('nonce incorrect, invalid tx')
logger.warning('subtype: %s', tx.type)
logger.warning('%s actual: %s expected: %s', tx.addr_from,
tx.nonce, expected_nonce)
return False
if addr_from_pk_state.ots_key_reuse(tx.ots_key):
logger.warning('pubkey reuse detected: invalid tx %s',
bin2hstr(tx.txhash))
logger.warning('subtype: %s', tx.type)
return False
tx.apply_state_changes(address_txn)
return True
def __next__(self):
tx_timestamp = self.transaction_pool_obj.get_pending_transaction()
if not tx_timestamp:
raise StopIteration
tx, timestamp = tx_timestamp
if not tx.validate():
return False
addr_from_state = self.chain_manager.get_address_state(
address=tx.addr_from)
addr_from_pk_state = addr_from_state
addr_from_pk = Transaction.get_slave(tx)
if addr_from_pk:
addr_from_pk_state = self.chain_manager.get_address_state(
address=addr_from_pk)
is_valid_state = tx.validate_extended(
addr_from_state=addr_from_state,
addr_from_pk_state=addr_from_pk_state)
if not is_valid_state:
logger.info('>>>TX %s failed is_valid_state', bin2hstr(tx.txhash))
return False
is_valid_pool_state = tx.validate_transaction_pool(
self.transaction_pool_obj.transaction_pool)
if not is_valid_pool_state:
logger.info('>>>TX %s failed is_valid_pool_state',
bin2hstr(tx.txhash))
return False
logger.info('A TXN has been Processed %s', bin2hstr(tx.txhash))
self.transaction_pool_obj.add_tx_to_pool(
tx, self.chain_manager.last_block.block_number, timestamp)
self.broadcast_tx(tx)
return True
def validate(self, state) -> bool:
addresses_set = set()
self.transaction.set_affected_address(addresses_set)
addresses_state = dict()
for address in addresses_set:
addresses_state[address] = state.get_address_state(address)
addr_from_pk_state = addresses_state[self.transaction.addr_from]
addr_from_pk = Transaction.get_slave(self.transaction)
if addr_from_pk:
addr_from_pk_state = addresses_state[addr_from_pk]
if not self.transaction.validate_extended(
addresses_state[self.transaction.addr_from],
addr_from_pk_state):
return False
return True
def create_block(self,
last_block,
mining_nonce,
tx_pool: TransactionPool,
miner_address) -> Optional[Block]:
seed_block = self._chain_manager.get_block_by_number(self._qn.get_seed_height(last_block.block_number + 1))
dev_config = self._chain_manager.get_config_by_block_number(block_number=last_block.block_number + 1)
dummy_block = Block.create(dev_config=dev_config,
block_number=last_block.block_number + 1,
prev_headerhash=last_block.headerhash,
prev_timestamp=last_block.timestamp,
transactions=[],
miner_address=miner_address,
seed_height=seed_block.block_number,
seed_hash=seed_block.headerhash)
dummy_block.set_nonces(dev_config, mining_nonce, 0)
t_pool2 = tx_pool.transactions
block_size = dummy_block.size
block_size_limit = self._chain_manager.get_block_size_limit(last_block, dev_config)
transactions = []
state_container = self._chain_manager.new_state_container(set(),
last_block.block_number,
True,
None)
for tx_set in t_pool2:
tx = tx_set[1].transaction
# Skip Transactions for later, which doesn't fit into block
if block_size + tx.size + dev_config.tx_extra_overhead > block_size_limit:
continue
if not self._chain_manager.update_state_container(tx, state_container):
logger.error("[create_block] Error updating state_container")
return None
if not tx.validate_all(state_container, check_nonce=False):
if not state_container.revert_update():
return None
tx_pool.remove_tx_from_pool(tx)
continue
if not self._chain_manager.apply_txn(tx, state_container):
logger.error("[create_block] Failed to apply txn")
if not state_container.revert_update():
return None
continue
addr_from_pk_state = state_container.addresses_state[tx.addr_from]
addr_from_pk = Transaction.get_slave(tx)
if addr_from_pk:
addr_from_pk_state = state_container.addresses_state[addr_from_pk]
tx._data.nonce = addr_from_pk_state.nonce
block_size += tx.size + dev_config.tx_extra_overhead
transactions.append(tx)
block = Block.create(dev_config=dev_config,
block_number=last_block.block_number + 1,
prev_headerhash=last_block.headerhash,
prev_timestamp=last_block.timestamp,
transactions=transactions,
miner_address=miner_address,
seed_height=seed_block.block_number,
seed_hash=seed_block.headerhash)
return block