def block_reward_calc(block_number): """ return block reward for the block_n :return: """ if block_number == 0: return config.dev.supplied_coins return int(block_reward(block_number))
def block_reward_calc(block_number, dev_config: DevConfig): """ return block reward for the block_n :return: """ if block_number == 0: return dev_config.supplied_coins return int(block_reward(block_number, dev_config))
def test_apply_coinbase_txn(self, m_logger): """ Alice earned some coins. """ addresses_state = { config.dev.coinbase_address: OptimizedAddressState.get_default(config.dev.coinbase_address), self.alice.address: OptimizedAddressState.get_default(self.alice.address), } addresses_state[ config.dev.coinbase_address].pbdata.balance = 1000000000000000 tx = CoinBase.create(config.dev, self.amount, self.alice.address, self.mock_blockheader.block_number) state_container = StateContainer( addresses_state=addresses_state, tokens=Indexer(b'token', None), slaves=Indexer(b'slave', None), lattice_pk=Indexer(b'lattice_pk', None), multi_sig_spend_txs=dict(), votes_stats=dict(), block_number=self.mock_blockheader.block_number, total_coin_supply=100, current_dev_config=config.dev, write_access=True, my_db=self.state._db, batch=None) # self.state.apply(tx, addresses_state) tx.apply(self.state, state_container) reward = int( block_reward(self.mock_blockheader.block_number, config.dev)) self.assertEqual(1000000000000000 - reward, addresses_state[config.dev.coinbase_address].balance) storage_key = state_container.paginated_tx_hash.generate_key( config.dev.coinbase_address, 1) self.assertEqual( [tx.txhash], state_container.paginated_tx_hash.key_value[storage_key]) self.assertEqual(tx.amount, addresses_state[self.alice.address].balance) storage_key = state_container.paginated_tx_hash.generate_key( self.alice.address, 1) self.assertEqual( [tx.txhash], state_container.paginated_tx_hash.key_value[storage_key])
def __init__(self, addresses_state: dict, tokens: Indexer, slaves: Indexer, lattice_pk: Indexer, multi_sig_spend_txs: dict, votes_stats: dict, block_number: int, total_coin_supply: int, current_dev_config: DevConfig, write_access: bool, my_db: db, batch): self.delete_keys = set() self.paginated_bitfield = PaginatedBitfield(write_access, my_db) self.paginated_tx_hash = PaginatedData(b'p_tx_hash', write_access, my_db) self.paginated_tokens_hash = PaginatedData(b'p_tokens', write_access, my_db) self.paginated_slaves_hash = PaginatedData(b'p_slaves', write_access, my_db) self.paginated_lattice_pk = PaginatedData(b'p_lattice_pk', write_access, my_db) self.paginated_multisig_address = PaginatedData( b'p_multisig_address', write_access, my_db) self.paginated_multi_sig_spend = PaginatedData(b'p_multi_sig_spend', write_access, my_db) self.paginated_inbox_message = PaginatedData(b'p_inbox_message', write_access, my_db) self.addresses_state = addresses_state self.tokens = tokens self.slaves = slaves self.lattice_pk = lattice_pk self.multi_sig_spend_txs = multi_sig_spend_txs self.votes_stats = votes_stats self.block_number = block_number # Block number that is being processed self.block_reward = int(block_reward(block_number, current_dev_config)) self.batch = batch self.db = my_db self.current_dev_config = current_dev_config # Keeps track of last update so that it can be reverted self.last_addresses_state = dict() self.last_tokens = Indexer(b'token', self.db) self.last_slaves = Indexer(b'slave', self.db) self.last_lattice_pk = Indexer(b'lattice_pk', self.db) self.last_multi_sig_spend_txs = dict() self.last_votes_stats = dict() self._total_coin_supply = total_coin_supply # TODO: Coinbase transaction of current block is not included
def block_reward_calc(self): """ return block reward for the block_n :return: """ return int(block_reward(self.block_number))