def test_add_vote3(self): vote_tracker = VoteTracker() validator_xmss1 = get_alice_xmss() slave_xmss1 = XMSS(validator_xmss1.height, validator_xmss1.get_seed()) stake_amount1 = 101.5012 headerhash1 = b'ffff' vote1 = Vote.create(addr_from=validator_xmss1.get_address().encode(), blocknumber=0, headerhash=headerhash1, xmss=slave_xmss1) vote1.sign(slave_xmss1) self.assertTrue(vote_tracker.add_vote(vote1, stake_amount1)) validator_xmss2 = get_random_xmss() slave_xmss2 = XMSS(validator_xmss2.height, validator_xmss2.get_seed()) headerhash2 = b'aaaa' stake_amount2 = 10000 vote2 = Vote.create(addr_from=validator_xmss2.get_address().encode(), blocknumber=0, headerhash=headerhash2, xmss=slave_xmss2) vote2.sign(slave_xmss2) self.assertTrue(vote_tracker.add_vote(vote2, stake_amount2)) vote_metadata = vote_tracker.get_consensus() self.assertNotEqual(vote_metadata, None) self.assertEqual(stake_amount2, vote_metadata.total_stake_amount) self.assertNotEqual(vote_tracker.get_consensus_headerhash(), headerhash1) self.assertEqual(vote_tracker.get_consensus_headerhash(), headerhash2)
def test_add_vote2(self): validator_xmss1 = get_alice_xmss() slave_xmss1 = XMSS(validator_xmss1.height, validator_xmss1.get_seed()) stake_amount1 = 101.5012 headerhash1 = b'ffff' vote1 = Vote.create(addr_from=validator_xmss1.get_address().encode(), blocknumber=0, headerhash=headerhash1, xmss=slave_xmss1) vote1.sign(slave_xmss1) vote_metadata = VoteMetadata() vote_metadata.add_vote(vote=vote1, stake_amount=stake_amount1) self.assertIn(vote1.txfrom, vote_metadata.stake_validator_vote) validator_xmss2 = get_random_xmss() slave_xmss2 = XMSS(validator_xmss2.height, validator_xmss2.get_seed()) stake_amount2 = 10000 headerhash2 = b'ffff' vote2 = Vote.create(addr_from=validator_xmss2.get_address().encode(), blocknumber=0, headerhash=headerhash2, xmss=slave_xmss2) vote2.sign(slave_xmss2) vote_metadata.add_vote(vote=vote2, stake_amount=stake_amount2) self.assertIn(vote2.txfrom, vote_metadata.stake_validator_vote) total_stake_amount = stake_amount1 + stake_amount2 self.assertEqual(total_stake_amount, vote_metadata.total_stake_amount)
def test_add_vote1(self): vote_tracker = VoteTracker() alice_xmss = get_alice_xmss() slave_xmss = XMSS(alice_xmss.height, alice_xmss.get_seed()) headerhash = b'ffff' vote = Vote.create(addr_from=alice_xmss.get_address().encode(), blocknumber=0, headerhash=headerhash, xmss=slave_xmss) vote.sign(slave_xmss) stake_amount = 101.5012 self.assertFalse(vote_tracker.is_already_voted(vote)) self.assertTrue(vote_tracker.add_vote(vote, stake_amount)) self.assertFalse(vote_tracker.add_vote(vote, stake_amount)) self.assertTrue(vote_tracker.is_already_voted(vote)) vote_metadata = vote_tracker.get_consensus() self.assertNotEqual(vote_metadata, None) self.assertIn(vote.addr_from, vote_metadata.stake_validator_vote) self.assertEqual(vote, vote_metadata.stake_validator_vote[vote.addr_from]) self.assertEqual(stake_amount, vote_metadata.total_stake_amount) self.assertEqual(vote_tracker.get_consensus_headerhash(), headerhash)
def pre_pos_1(self, data=None): # triggered after genesis for block 1.. logger.info('pre_pos_1') # are we a staker in the stake list? genesis_block = self.buffered_chain.get_block(0) found = False for genesisBalance in genesis_block.genesis_balance: if genesisBalance.address.encode( ) == self.buffered_chain.staking_address: logger.info('Found in Genesis Address %s %s', genesisBalance.address.encode(), genesisBalance.balance) found = True break if not found: return logger.info('mining address: %s in the genesis.stake_list', self.buffered_chain.staking_address) xmss = self.buffered_chain.wallet.address_bundle[0].xmss tmphc = hashchain(xmss.get_seed_private(), epoch=0) self.buffered_chain.hash_chain[0] = tmphc.hashchain slave_xmss = self.buffered_chain.get_slave_xmss(0) if not slave_xmss: logger.info('Waiting for SLAVE XMSS to be done') reactor.callLater(5, self.pre_pos_1) return signing_xmss = self.buffered_chain.wallet.address_bundle[0].xmss st = StakeTransaction.create(activation_blocknumber=1, xmss=signing_xmss, slavePK=slave_xmss.pk(), hashchain_terminator=tmphc.hc_terminator) st.sign(signing_xmss) self.buffered_chain.tx_pool.add_tx_to_pool(st) # send the stake tx to generate hashchain terminators for the staker addresses.. self.p2p_factory.broadcast_st(st) vote = Vote.create( addr_from=self.buffered_chain.wallet.address_bundle[0].address, blocknumber=0, headerhash=genesis_block.headerhash, xmss=slave_xmss) vote.sign(slave_xmss) self.buffered_chain.add_vote(vote) # send the stake votes for genesis block self.p2p_factory.broadcast_vote(vote) logger.info('await delayed call to build staker list from genesis') reactor.callLater(5, self.pre_pos_2, st)
def test_add_vote1(self): alice_xmss = get_alice_xmss() slave_xmss = XMSS(alice_xmss.height, alice_xmss.get_seed()) headerhash = b'ffff' vote = Vote.create(addr_from=alice_xmss.get_address().encode(), blocknumber=0, headerhash=headerhash, xmss=slave_xmss) vote.sign(slave_xmss) stake_amount = 101.5012 vote_metadata = VoteMetadata() self.assertNotIn(vote.txfrom, vote_metadata.stake_validator_vote) vote_metadata.add_vote(vote=vote, stake_amount=stake_amount) self.assertIn(vote.txfrom, vote_metadata.stake_validator_vote) self.assertEqual(stake_amount, vote_metadata.total_stake_amount)
def create_vote_tx(self, blocknumber: int): block = self.buffered_chain.get_block(blocknumber) if not block: logger.warning('Block #%s not found, cancelled voting', blocknumber) return signing_xmss = self.buffered_chain.get_slave_xmss(blocknumber) if not signing_xmss: logger.warning( 'Skipped Voting: Slave XMSS none, XMSS POOL might still be generating slave_xmss' ) return vote = Vote.create( addr_from=self.buffered_chain.wallet.address_bundle[0].address, blocknumber=blocknumber, headerhash=block.blockheader.headerhash, xmss=signing_xmss) vote.sign(signing_xmss) # FIXME: Temporary fix, need to add ST txn into Genesis if blocknumber > 1: tx_state = self.buffered_chain.get_stxn_state( blocknumber + 1, vote.addr_from) stake_validators_tracker = self.buffered_chain.get_stake_validators_tracker( blocknumber) if not (vote.validate() and vote.validate_extended( tx_state, stake_validators_tracker.sv_dict)): logger.warning( 'Create Vote Txn failed due to validation failure') return self.buffered_chain.set_voted(blocknumber) self.buffered_chain.add_vote(vote) self.p2p_factory.broadcast_vote(vote)
def test_from_txdict(self): tx = Vote.create(self.addr_from, self.blocknumber, self.headerhash, self.alice) self.assertIsInstance(tx, Vote) # Test that common Transaction components were copied over. self.assertEqual(0, tx.nonce) self.assertEqual( b'Q223bc5e5b78edfd778b1bf72702061cc053010711ffeefb9d969318be5d7b86b021b73c2', tx.txfrom) self.assertEqual( '3c523f9cc26f800863c003524392806ff6df373acb4d47cc607b62365fe4ab77' 'cf3018d321df7dcb653c9f7968673e43d12cc26e3461b5f425fd5d977400fea5', bin2hstr(tx.PK)) self.assertEqual(11, tx.ots_key) self.assertEqual(b'', tx.signature) self.assertEqual( '1a1274bedfc53287853c3aea5b8a93d64f2e4dff23ddbf96e52c8033f0107154', bin2hstr(tx.pubhash)) self.assertEqual( 'b77410e48e9d8ee140c8b49d6331152e090fe3acc5dcd7e4cd3b4ea6bf8c3839', bin2hstr(tx.txhash))
def test_add_2(self): destroy_state() with State() as state: with set_wallet_dir("test_wallet"): chain = Chain(state) buffered_chain = BufferedChain(chain) alice_xmss = get_alice_xmss() slave_xmss = XMSS(alice_xmss.height, alice_xmss.get_seed()) staking_address = bytes(alice_xmss.get_address().encode()) h0 = sha256(b'hashchain_seed') h1 = sha256(h0) with mocked_genesis() as custom_genesis: custom_genesis.genesis_balance.extend([ qrl_pb2.GenesisBalance( address=alice_xmss.get_address(), balance=700000000000000) ]) res = buffered_chain.add_block(block=custom_genesis) self.assertTrue(res) stake_transaction = StakeTransaction.create( activation_blocknumber=1, xmss=alice_xmss, slavePK=slave_xmss.pk(), hashchain_terminator=h1) vote = Vote.create( addr_from=alice_xmss.get_address().encode(), blocknumber=0, headerhash=custom_genesis.headerhash, xmss=slave_xmss) vote.sign(slave_xmss) buffered_chain.add_vote(vote) vote_metadata = buffered_chain.get_consensus(0) # FIXME: The test needs private access.. This is an API issue stake_transaction._data.nonce = 1 stake_transaction.sign(alice_xmss) chain.pstate.stake_validators_tracker.add_sv( balance=700000000000000, stake_txn=stake_transaction, blocknumber=1) sv = chain.pstate.stake_validators_tracker.sv_dict[ staking_address] self.assertEqual(0, sv.nonce) tmp_block = Block.create( staking_address=bytes( alice_xmss.get_address().encode()), block_number=1, reveal_hash=h0, prevblock_headerhash=custom_genesis.headerhash, transactions=[stake_transaction], duplicate_transactions=OrderedDict(), vote=vote_metadata, signing_xmss=alice_xmss, nonce=1) res = buffered_chain.add_block(block=tmp_block) self.assertTrue(res)
def test_add_4(self): destroy_state() with State() as state: with set_wallet_dir("test_wallet"): chain = Chain(state) buffered_chain = BufferedChain(chain) alice_xmss = get_alice_xmss() slave_xmss = XMSS(alice_xmss.height, alice_xmss.get_seed()) random_xmss1 = get_random_xmss() random_xmss2 = get_random_xmss() staking_address = bytes(alice_xmss.get_address().encode()) # FIXME: Replace this with a call to create a hash_chain h0 = sha256(b'hashchain_seed') h1 = sha256(h0) h2 = sha256(h1) h3 = sha256(h2) h4 = sha256(h3) with mocked_genesis() as custom_genesis: custom_genesis.genesis_balance.extend([ qrl_pb2.GenesisBalance( address=alice_xmss.get_address(), balance=700000000000000) ]) res = buffered_chain.add_block(block=GenesisBlock()) self.assertTrue(res) stake_transaction = StakeTransaction.create( activation_blocknumber=1, xmss=alice_xmss, slavePK=slave_xmss.pk(), hashchain_terminator=h4) stake_transaction._data.nonce = 1 # FIXME: The test needs private access.. This is an API issue stake_transaction.sign(alice_xmss) vote = Vote.create( addr_from=alice_xmss.get_address().encode(), blocknumber=0, headerhash=GenesisBlock().headerhash, xmss=slave_xmss) vote.sign(slave_xmss) buffered_chain.add_vote(vote) vote_metadata = buffered_chain.get_consensus(0) chain.pstate.stake_validators_tracker.add_sv( balance=700000000000000, stake_txn=stake_transaction, blocknumber=1) sv = chain.pstate.stake_validators_tracker.sv_dict[ staking_address] self.assertEqual(0, sv.nonce) # Token Transaction to create a token for test token_transaction = get_token_transaction( random_xmss1, random_xmss2) token_transaction._data.nonce = 1 token_transaction.sign(random_xmss1) # Transfer Token Transaction transfer_token1 = TransferTokenTransaction.create( addr_from=random_xmss1.get_address().encode(), token_txhash=token_transaction.txhash, addr_to=alice_xmss.get_address().encode(), amount=100000000, fee=1, xmss_pk=random_xmss1.pk(), xmss_ots_index=random_xmss1.get_index()) transfer_token1._data.nonce = 2 transfer_token1.sign(random_xmss1) transfer_token2 = TransferTokenTransaction.create( addr_from=random_xmss2.get_address().encode(), token_txhash=token_transaction.txhash, addr_to=alice_xmss.get_address().encode(), amount=200000000, fee=1, xmss_pk=random_xmss2.pk(), xmss_ots_index=random_xmss2.get_index()) transfer_token2._data.nonce = 1 transfer_token2.sign(random_xmss2) # Transfer Coin Transaction transfer_transaction = TransferTransaction.create( addr_from=random_xmss1.get_address().encode(), addr_to=random_xmss2.get_address().encode(), amount=10, fee=1, xmss_pk=random_xmss1.pk(), xmss_ots_index=random_xmss1.get_index()) transfer_transaction._data.nonce = 3 transfer_transaction.sign(random_xmss1) tmp_block1 = Block.create( staking_address=staking_address, block_number=1, reveal_hash=h3, prevblock_headerhash=GenesisBlock().headerhash, transactions=[stake_transaction, token_transaction], duplicate_transactions=OrderedDict(), vote=vote_metadata, signing_xmss=slave_xmss, nonce=1) res = buffered_chain.add_block(block=tmp_block1) self.assertTrue(res) # Need to move forward the time to align with block times with mock.patch('qrl.core.ntp.getTime') as time_mock: time_mock.return_value = tmp_block1.timestamp + config.dev.minimum_minting_delay vote = Vote.create( addr_from=alice_xmss.get_address().encode(), blocknumber=1, headerhash=tmp_block1.headerhash, xmss=slave_xmss) vote.sign(slave_xmss) buffered_chain.add_vote(vote) vote_metadata = buffered_chain.get_consensus(1) tmp_block2 = Block.create( staking_address=staking_address, block_number=2, reveal_hash=h2, prevblock_headerhash=tmp_block1.headerhash, transactions=[ transfer_token1, transfer_token2, transfer_transaction ], duplicate_transactions=OrderedDict(), vote=vote_metadata, signing_xmss=slave_xmss, nonce=2) res = buffered_chain.add_block(block=tmp_block2) self.assertTrue(res) # Need to move forward the time to align with block times with mock.patch('qrl.core.ntp.getTime') as time_mock: time_mock.return_value = tmp_block2.timestamp + config.dev.minimum_minting_delay vote = Vote.create( addr_from=alice_xmss.get_address().encode(), blocknumber=2, headerhash=tmp_block2.headerhash, xmss=slave_xmss) vote.sign(slave_xmss) buffered_chain.add_vote(vote) vote_metadata = buffered_chain.get_consensus(2) tmp_block3 = Block.create( staking_address=staking_address, block_number=3, reveal_hash=h1, prevblock_headerhash=tmp_block2.headerhash, transactions=[], duplicate_transactions=OrderedDict(), vote=vote_metadata, signing_xmss=slave_xmss, nonce=3) res = buffered_chain.add_block(block=tmp_block3) self.assertTrue(res) chain = buffered_chain._chain random_xmss1_state = chain.pstate._get_address_state( random_xmss1.get_address().encode()) random_xmss2_state = chain.pstate._get_address_state( random_xmss2.get_address().encode()) self.assertEqual( random_xmss1_state.tokens[bin2hstr( token_transaction.txhash).encode()], 400000000) self.assertEqual( random_xmss2_state.tokens[bin2hstr( token_transaction.txhash).encode()], 200000000) # Need to move forward the time to align with block times with mock.patch('qrl.core.ntp.getTime') as time_mock: time_mock.return_value = tmp_block3.timestamp + config.dev.minimum_minting_delay vote = Vote.create( addr_from=alice_xmss.get_address().encode(), blocknumber=3, headerhash=tmp_block3.headerhash, xmss=slave_xmss) vote.sign(slave_xmss) buffered_chain.add_vote(vote) vote_metadata = buffered_chain.get_consensus(3) tmp_block4 = Block.create( staking_address=staking_address, block_number=4, reveal_hash=h0, prevblock_headerhash=tmp_block3.headerhash, transactions=[], duplicate_transactions=OrderedDict(), vote=vote_metadata, signing_xmss=slave_xmss, nonce=4) res = buffered_chain.add_block(block=tmp_block4) self.assertTrue(res) token_metadata = buffered_chain.get_token_metadata( token_transaction.txhash) self.assertEqual(token_metadata.token_txhash, token_transaction.txhash) self.assertEqual( len(token_metadata.transfer_token_tx_hashes), 3) self.assertEqual( token_metadata.transfer_token_tx_hashes[0], token_transaction.txhash) random_xmss1_state = chain.pstate._get_address_state( random_xmss1.get_address().encode()) random_xmss2_state = chain.pstate._get_address_state( random_xmss2.get_address().encode()) alice_state = chain.pstate._get_address_state( alice_xmss.get_address().encode()) self.assertEqual( random_xmss1_state.tokens[bin2hstr( token_transaction.txhash).encode()], 300000000) self.assertEqual( random_xmss2_state.tokens[bin2hstr( token_transaction.txhash).encode()], 0) self.assertEqual( alice_state.tokens[bin2hstr( token_transaction.txhash).encode()], 300000000) self.assertEqual(random_xmss1_state.balance, config.dev.default_account_balance - 13) self.assertEqual(random_xmss2_state.balance, config.dev.default_account_balance + 9)
def test_add_3(self): destroy_state() with State() as state: with set_wallet_dir("test_wallet"): chain = Chain(state) buffered_chain = BufferedChain(chain) alice_xmss = get_alice_xmss() slave_xmss = XMSS(alice_xmss.height, alice_xmss.get_seed()) staking_address = bytes(alice_xmss.get_address().encode()) # FIXME: Replace this with a call to create a hash_chain h0 = sha256(b'hashchain_seed') h1 = sha256(h0) h2 = sha256(h1) h3 = sha256(h2) with mocked_genesis() as custom_genesis: custom_genesis.genesis_balance.extend([ qrl_pb2.GenesisBalance( address=alice_xmss.get_address(), balance=700000000000000) ]) res = buffered_chain.add_block(block=GenesisBlock()) self.assertTrue(res) stake_transaction = StakeTransaction.create( activation_blocknumber=1, xmss=alice_xmss, slavePK=slave_xmss.pk(), hashchain_terminator=h3) stake_transaction._data.nonce = 1 # FIXME: The test needs private access.. This is an API issue stake_transaction.sign(alice_xmss) vote = Vote.create( addr_from=alice_xmss.get_address().encode(), blocknumber=0, headerhash=GenesisBlock().headerhash, xmss=slave_xmss) vote.sign(slave_xmss) buffered_chain.add_vote(vote) vote_metadata = buffered_chain.get_consensus(0) chain.pstate.stake_validators_tracker.add_sv( balance=700000000000000, stake_txn=stake_transaction, blocknumber=1) sv = chain.pstate.stake_validators_tracker.sv_dict[ staking_address] self.assertEqual(0, sv.nonce) tmp_block1 = Block.create( staking_address=staking_address, block_number=1, reveal_hash=h2, prevblock_headerhash=GenesisBlock().headerhash, transactions=[stake_transaction], duplicate_transactions=OrderedDict(), vote=vote_metadata, signing_xmss=slave_xmss, nonce=1) res = buffered_chain.add_block(block=tmp_block1) self.assertTrue(res) # Need to move forward the time to align with block times with mock.patch('qrl.core.ntp.getTime') as time_mock: time_mock.return_value = tmp_block1.timestamp + config.dev.minimum_minting_delay vote = Vote.create( addr_from=alice_xmss.get_address().encode(), blocknumber=1, headerhash=tmp_block1.headerhash, xmss=slave_xmss) vote.sign(slave_xmss) buffered_chain.add_vote(vote) vote_metadata = buffered_chain.get_consensus(1) tmp_block2 = Block.create( staking_address=staking_address, block_number=2, reveal_hash=h1, prevblock_headerhash=tmp_block1.headerhash, transactions=[], duplicate_transactions=OrderedDict(), vote=vote_metadata, signing_xmss=slave_xmss, nonce=2) res = buffered_chain.add_block(block=tmp_block2) self.assertTrue(res) # Need to move forward the time to align with block times with mock.patch('qrl.core.ntp.getTime') as time_mock: time_mock.return_value = tmp_block2.timestamp + config.dev.minimum_minting_delay vote = Vote.create( addr_from=alice_xmss.get_address().encode(), blocknumber=2, headerhash=tmp_block2.headerhash, xmss=slave_xmss) vote.sign(slave_xmss) buffered_chain.add_vote(vote) vote_metadata = buffered_chain.get_consensus(2) tmp_block3 = Block.create( staking_address=staking_address, block_number=3, reveal_hash=h0, prevblock_headerhash=tmp_block2.headerhash, transactions=[], duplicate_transactions=OrderedDict(), vote=vote_metadata, signing_xmss=slave_xmss, nonce=3) res = buffered_chain.add_block(block=tmp_block3) self.assertTrue(res)
def test_to_json(self): tx = Vote.create(self.addr_from, self.blocknumber, self.headerhash, self.alice) txjson = tx.to_json() print(txjson) self.assertEqual(json.loads(test_json_Vote), json.loads(txjson))
def test_create(self): tx = Vote.create(self.addr_from, self.blocknumber, self.headerhash, self.alice) self.assertIsInstance(tx, Vote)