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))
