def test_insert(self):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
p.insert(OptimizedAddressState.get_default(b'a'), b'10')
self.assertEqual(p.get_value(b'a', 0), [b'10'])
def revert(self, state_container, multi_sig_spend, addresses_state: dict,
paginated_tx_hash: PaginatedData, current_block_number: int,
threshold: int) -> bool:
if not self.executed:
return True
if self.total_weight < threshold:
return False
if current_block_number > self.expiry_block_number:
return False
addresses_state[self.multi_sig_address].update_balance(
state_container, multi_sig_spend.total_amount)
addr_from_pk = bytes(QRLHelper.getAddress(multi_sig_spend.PK))
for index in range(0, len(multi_sig_spend.addrs_to)):
addr_to = multi_sig_spend.addrs_to[index]
address_state = addresses_state[addr_to]
if addr_to not in (multi_sig_spend.addr_from, addr_from_pk):
paginated_tx_hash.remove(address_state, multi_sig_spend.txhash)
address_state.update_balance(state_container,
multi_sig_spend.amounts[index],
subtract=True)
self._data.executed = False
return True
def test_get_value(self):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
storage_key = p.generate_key(b'a', 0)
p.key_value[storage_key] = [10]
self.assertEqual(p.get_value(b'a', 0), [10])
def test_reset_key_value(self):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
self.assertEqual(len(p.key_value), 0)
p.key_value[b'a'] = [10]
self.assertEqual(len(p.key_value), 1)
p.reset_key_value()
self.assertEqual(len(p.key_value), 0)
def test_remove(self, mock_dev_config):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
key = b'test_key'
value = [b'hello world']
storage_key = p.generate_key(key, 11)
p.put(storage_key, value, None)
found_value = p.get_paginated_data(key, 11)
self.assertEqual(value, found_value)
p.delete(storage_key, None)
found_value = p.get_paginated_data(key, 11)
self.assertEqual([], found_value)
def test_get_paginated_data(self, mock_dev_config):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
alice_address_state = OptimizedAddressState.get_default(
address=self.alice.address)
total_hashes = 25
expected_full_hash = []
for i in range(0, total_hashes):
tx_hash = b'p_tx_hash_' + i.to_bytes(
8, byteorder='big', signed=False)
p.insert(alice_address_state, tx_hash)
expected_full_hash.append(tx_hash)
p.put_paginated_data(None)
found_full_hash = []
expected_data_count = [10, 10, 5]
for i in range(0, (total_hashes // config.dev.data_per_page) + 1):
data = p.get_paginated_data(
self.alice.address, (i + 1) * config.dev.data_per_page - 1)
self.assertEqual(len(data), expected_data_count[i])
found_full_hash.extend(data)
self.assertEqual(expected_full_hash, found_full_hash)
def apply(self, state_container, multi_sig_spend, addresses_state: dict,
paginated_tx_hash: PaginatedData, current_block_number: int,
threshold: int) -> bool:
# TODO: return False if executed
if self.executed:
return True
if self.total_weight < threshold:
return False
if current_block_number > self.expiry_block_number:
return False
if multi_sig_spend.total_amount > addresses_state[
self.multi_sig_address].balance:
logger.info(
"[VoteStats] Insufficient funds to execute Multi Sig Spend")
logger.info("Multi Sig Spend Amount: %s, Funds Available: %s",
multi_sig_spend.total_amount,
addresses_state[self.multi_sig_address].balance)
logger.info("Multi Sig Spend txn hash: %s",
bin2hstr(multi_sig_spend.txhash))
logger.info("Multi Sig Address: %s",
bin2hstr(multi_sig_spend.multi_sig_address))
return False
addresses_state[self.multi_sig_address].update_balance(
state_container, multi_sig_spend.total_amount, subtract=True)
addr_from_pk = bytes(QRLHelper.getAddress(multi_sig_spend.PK))
for index in range(0, len(multi_sig_spend.addrs_to)):
addr_to = multi_sig_spend.addrs_to[index]
address_state = addresses_state[addr_to]
if addr_to not in (multi_sig_spend.addr_from, addr_from_pk):
paginated_tx_hash.insert(address_state, multi_sig_spend.txhash)
address_state.update_balance(state_container,
multi_sig_spend.amounts[index])
self._data.executed = True
return True
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 test_put_paginated_data(self, mock_dev_config):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
alice_address_state = OptimizedAddressState.get_default(
address=self.alice.address)
for i in range(0, 10):
p.insert(
alice_address_state, b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
self.assertEqual(
alice_address_state.get_counter_by_name(p.name), i + 1)
p.put_paginated_data(None)
self.assertEqual(alice_address_state.get_counter_by_name(p.name),
10)
for i in range(10, 25):
p.insert(
alice_address_state, b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
self.assertEqual(
alice_address_state.get_counter_by_name(p.name), i + 1)
p.put_paginated_data(None)
self.assertEqual(alice_address_state.get_counter_by_name(p.name),
25)
self.assertEqual(len(p.key_value), 0)
pages_data = []
for i in range(0, (25 // config.dev.data_per_page) + 1):
data = p.get_paginated_data(
self.alice.address, (i + 1) * config.dev.data_per_page - 1)
pages_data.append(data)
self.assertEqual(len(pages_data), 3)
self.assertEqual(len(pages_data[0]), 10)
for i in range(0, 10):
self.assertEqual(
pages_data[0][i], b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
self.assertEqual(len(pages_data[1]), 10)
for i in range(10, 20):
self.assertEqual(
pages_data[1][i - 10], b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
self.assertEqual(len(pages_data[2]), 5)
for i in range(20, 25):
self.assertEqual(
pages_data[2][i - 20], b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
def test_revert_paginated_data2(self, mock_dev_config):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
alice_address_state = OptimizedAddressState.get_default(
address=self.alice.address)
for i in range(0, 25):
p.insert(
alice_address_state, b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
p.put_paginated_data(None)
full_hash = []
for i in range(0, (25 // config.dev.data_per_page) + 1):
data = p.get_paginated_data(
self.alice.address, (i + 1) * config.dev.data_per_page - 1)
full_hash.extend(data)
for tx_hash in full_hash[-1::-1]:
p.remove(alice_address_state, tx_hash)
p.put_paginated_data(None)
self.assertEqual(
alice_address_state.get_counter_by_name(b'p_tx_hash'), 0)
self.assertEqual(
len(p.get_paginated_data(alice_address_state.address, 22)), 0)
self.assertEqual(
len(p.get_paginated_data(alice_address_state.address, 12)), 0)
self.assertEqual(
len(p.get_paginated_data(alice_address_state.address, 2)), 0)