def test_revert_multi_sig_create_txn(self):
addresses_state = {
self.alice.address:
OptimizedAddressState.get_default(self.alice.address),
self.bob.address:
OptimizedAddressState.get_default(self.bob.address),
self.random.address:
OptimizedAddressState.get_default(self.random.address),
self.random_signer.address:
OptimizedAddressState.get_default(self.random_signer.address),
}
addresses_state[self.random_signer.address].pbdata.balance = 200
tx = MultiSigCreate.create(self.signatories, self.weights,
self.threshold, 1, self.random_signer.pk)
tx.sign(self.random_signer)
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=1,
total_coin_supply=100,
current_dev_config=config.dev,
write_access=True,
my_db=self.state._db,
batch=None)
self.assertFalse(
state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse(
self.random_signer.address, tx.ots_key))
tx.apply(self.state, state_container)
self.assertEqual(200 - tx.fee,
addresses_state[self.random_signer.address].balance)
storage_key = state_container.paginated_tx_hash.generate_key(
self.random_signer.address, 1)
self.assertEqual(
[tx.txhash],
state_container.paginated_tx_hash.key_value[storage_key])
for signatory_address in self.signatories:
storage_key = state_container.paginated_tx_hash.generate_key(
signatory_address, 1)
self.assertEqual(
[tx.txhash],
state_container.paginated_tx_hash.key_value[storage_key])
self.assertTrue(
state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse(
self.random_signer.address, tx.ots_key))
AddressState.put_addresses_state(self.state, addresses_state)
state_container.paginated_multisig_address.put_paginated_data(None)
multi_sig_addresses_state = MultiSigAddressState.get_multi_sig_address_state_by_address(
self.state._db,
MultiSigAddressState.generate_multi_sig_address(tx.txhash))
self.assertEqual(self.signatories,
multi_sig_addresses_state.signatories)
self.assertEqual(self.weights, multi_sig_addresses_state.weights)
self.assertEqual(self.threshold, multi_sig_addresses_state.threshold)
for signatory_address in self.signatories:
multi_sig_addresses = state_container.paginated_multisig_address.get_paginated_data(
signatory_address, 1)
self.assertEqual(len(multi_sig_addresses), 1)
tx.revert(self.state, state_container)
state_container.paginated_multisig_address.put_paginated_data(None)
self.assertFalse(
state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse(
self.random_signer.address, tx.ots_key))
self.assertIsNone(
MultiSigAddressState.get_multi_sig_address_state_by_address(
self.state._db,
MultiSigAddressState.generate_multi_sig_address(tx.txhash)))
for signatory_address in self.signatories:
multi_sig_addresses = state_container.paginated_multisig_address.get_paginated_data(
signatory_address, 1)
self.assertEqual(len(multi_sig_addresses), 0)
def test_revert(self):
multi_sig_address = MultiSigAddressState.generate_multi_sig_address(
b'')
spend_tx = MultiSigSpend.create(multi_sig_address=multi_sig_address,
addrs_to=[self.alice.address],
amounts=[100],
expiry_block_number=15000,
fee=0,
xmss_pk=self.alice.pk)
spend_tx.sign(self.alice)
tx = MultiSigVote.create(shared_key=spend_tx.txhash,
unvote=False,
fee=5,
xmss_pk=self.alice.pk)
tx.sign(self.alice)
alice_address_state = OptimizedAddressState.get_default(
address=self.alice.address)
alice_address_state.pbdata.balance = 5
multi_sig_address_state = MultiSigAddressState.create(
creation_tx_hash=b'',
balance=100,
signatories=[self.alice.address, self.bob.address],
weights=[4, 6],
threshold=5,
transaction_hash_count=0)
addresses_state = {
self.alice.address: alice_address_state,
multi_sig_address: multi_sig_address_state,
}
vote_stats = {
spend_tx.txhash:
VoteStats.create(multi_sig_address=multi_sig_address,
shared_key=spend_tx.txhash,
signatories=multi_sig_address_state.signatories,
expiry_block_number=spend_tx.expiry_block_number),
}
multi_sig_spend_txs = {
spend_tx.txhash: spend_tx,
}
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=multi_sig_spend_txs,
votes_stats=vote_stats,
block_number=10,
total_coin_supply=100,
current_dev_config=config.dev,
write_access=True,
my_db=self.state._db,
batch=None)
self.assertFalse(
state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse(
self.alice.address, tx.ots_key))
tx.apply(self.state, state_container)
self.assertTrue(
state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse(
self.alice.address, tx.ots_key))
self.assertIn(spend_tx.txhash, state_container.votes_stats)
vote_stats = state_container.votes_stats[spend_tx.txhash]
unvote, index = vote_stats.get_unvote_by_address(tx.addr_from)
self.assertNotEqual(index, -1)
self.assertFalse(unvote)
self.assertEqual(vote_stats.shared_key, spend_tx.txhash)
self.assertEqual(vote_stats.total_weight, 4)
self.assertEqual(vote_stats.signatories,
multi_sig_address_state.signatories)
tx.revert(self.state, state_container)
self.assertIn(spend_tx.txhash, state_container.votes_stats)
vote_stats = state_container.votes_stats[spend_tx.txhash]
unvote, index = vote_stats.get_unvote_by_address(tx.addr_from)
self.assertNotEqual(index, -1)
self.assertTrue(unvote)
self.assertEqual(vote_stats.shared_key, spend_tx.txhash)
self.assertEqual(vote_stats.total_weight, 0)
self.assertEqual(vote_stats.signatories,
multi_sig_address_state.signatories)
self.assertFalse(
state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse(
self.alice.address, tx.ots_key))
def test_validate_extended(self):
multi_sig_address = MultiSigAddressState.generate_multi_sig_address(
b'')
spend_tx = MultiSigSpend.create(multi_sig_address=multi_sig_address,
addrs_to=[self.alice.address],
amounts=[100],
expiry_block_number=15000,
fee=0,
xmss_pk=self.alice.pk)
spend_tx.sign(self.alice)
tx = MultiSigVote.create(shared_key=spend_tx.txhash,
unvote=False,
fee=5,
xmss_pk=self.alice.pk)
tx.sign(self.alice)
alice_address_state = OptimizedAddressState.get_default(
address=self.alice.address)
alice_address_state.pbdata.balance = 5
multi_sig_address_state = MultiSigAddressState.create(
creation_tx_hash=b'',
balance=100,
signatories=[self.alice.address, self.bob.address],
weights=[4, 6],
threshold=5,
transaction_hash_count=0)
addresses_state = {
self.alice.address: alice_address_state,
multi_sig_address: multi_sig_address_state,
}
vote_stats = {
spend_tx.txhash:
VoteStats.create(multi_sig_address=multi_sig_address,
shared_key=spend_tx.txhash,
signatories=multi_sig_address_state.signatories,
expiry_block_number=spend_tx.expiry_block_number),
}
multi_sig_spend_txs = {
spend_tx.txhash: spend_tx,
}
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=multi_sig_spend_txs,
votes_stats=vote_stats,
block_number=10,
total_coin_supply=100,
current_dev_config=config.dev,
write_access=True,
my_db=None,
batch=None)
result = tx._validate_extended(state_container)
self.assertTrue(result)
tx._data.multi_sig_vote.unvote = True
result = tx._validate_extended(state_container)
self.assertFalse(result)
tx._data.multi_sig_vote.unvote = False
result = tx._validate_extended(state_container)
self.assertTrue(result)
alice_address_state.pbdata.balance = 0
result = tx._validate_extended(state_container)
self.assertFalse(result)
alice_address_state.pbdata.balance = 5
result = tx._validate_extended(state_container)
self.assertTrue(result)
state_container.block_number = 15000
result = tx._validate_extended(state_container)
self.assertTrue(result)
state_container.block_number = 15001
result = tx._validate_extended(state_container)
self.assertFalse(result)
def test_validate_all(self):
"""
Test for Validate Extended when transaction has been signed by slave.
:return:
"""
multi_sig_address = MultiSigAddressState.generate_multi_sig_address(
b'')
spend_tx = MultiSigSpend.create(multi_sig_address=multi_sig_address,
addrs_to=[self.alice.address],
amounts=[100],
expiry_block_number=15000,
fee=0,
xmss_pk=self.alice.pk)
spend_tx.sign(self.alice)
tx = MultiSigVote.create(shared_key=spend_tx.txhash,
unvote=False,
fee=5,
xmss_pk=self.random.pk,
master_addr=self.alice.address)
tx.sign(self.random)
tx._data.nonce = 1
alice_address_state = OptimizedAddressState.get_default(
address=self.alice.address)
alice_address_state.pbdata.balance = 5
random_address_state = OptimizedAddressState.get_default(
address=self.random.address)
multi_sig_address_state = MultiSigAddressState.create(
creation_tx_hash=b'',
balance=100,
signatories=[self.alice.address, self.bob.address],
weights=[4, 6],
threshold=5,
transaction_hash_count=0)
addresses_state = {
self.alice.address: alice_address_state,
self.random.address: random_address_state,
multi_sig_address: multi_sig_address_state,
}
vote_stats = {
spend_tx.txhash:
VoteStats.create(multi_sig_address=multi_sig_address,
shared_key=spend_tx.txhash,
signatories=multi_sig_address_state.signatories,
expiry_block_number=spend_tx.expiry_block_number),
}
multi_sig_spend_txs = {
spend_tx.txhash: spend_tx,
}
slaves = Indexer(b'slave', None)
slaves.data[(self.alice.address,
self.random.pk)] = SlaveMetadata(access_type=0)
state_container = StateContainer(
addresses_state=addresses_state,
tokens=Indexer(b'token', None),
slaves=slaves,
lattice_pk=Indexer(b'lattice_pk', None),
multi_sig_spend_txs=multi_sig_spend_txs,
votes_stats=vote_stats,
block_number=10,
total_coin_supply=100,
current_dev_config=config.dev,
write_access=False,
my_db=self.state._db,
batch=None)
result = tx.validate_all(state_container)
self.assertTrue(result)
tx._data.nonce = 2
result = tx.validate_all(state_container)
self.assertFalse(result) # False as nonce is invalid