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