From 959d2e98f018e06925f909904b64db91f6b742ad Mon Sep 17 00:00:00 2001 From: ArpitShukla007 Date: Wed, 2 Feb 2022 08:03:42 +0000 Subject: [PATCH] Resolved PubKey issue --- planetmint/core.py | 38 +- planetmint/parallel_validation.py | 2 +- .../upsert_validator/validator_utils.py | 5 +- tests/tendermint/conftest.py | 4 +- tests/test_core.py | 611 +++++++++++++++--- 5 files changed, 544 insertions(+), 116 deletions(-) diff --git a/planetmint/core.py b/planetmint/core.py index ab9a99f..65d6a10 100644 --- a/planetmint/core.py +++ b/planetmint/core.py @@ -62,29 +62,29 @@ class App(BaseApplication): transaction logic to Tendermint Core. """ - def __init__(self, planetmint=None, events_queue=None,): + def __init__(self, planetmint_node=None, events_queue=None,): #super().__init__(abci) logger.debug('Checking values of types') logger.debug(dir(types_pb2)) self.events_queue = events_queue - self.planetmint = planetmint or Planetmint() + self.planetmint_node = planetmint_node or Planetmint() self.block_txn_ids = [] self.block_txn_hash = '' self.block_transactions = [] self.validators = None self.new_height = None - self.chain = self.planetmint.get_latest_abci_chain() + self.chain = self.planetmint_node.get_latest_abci_chain() def log_abci_migration_error(self, chain_id, validators): logger.error('An ABCI chain migration is in process. ' - 'Download the new ABCI client and configure it with ' + 'Download theself.planetmint_node.get_latest_abci_chain new ABCI client and configure it with ' f'chain_id={chain_id} and validators={validators}.') def abort_if_abci_chain_is_not_synced(self): if self.chain is None or self.chain['is_synced']: return - validators = self.planetmint.get_validators() + validators = self.planetmint_node.get_validators() self.log_abci_migration_error(self.chain['chain_id'], validators) sys.exit(1) @@ -94,7 +94,7 @@ class App(BaseApplication): app_hash = '' height = 0 - known_chain = self.planetmint.get_latest_abci_chain() + known_chain = self.planetmint_node.get_latest_abci_chain() if known_chain is not None: chain_id = known_chain['chain_id'] @@ -105,16 +105,16 @@ class App(BaseApplication): sys.exit(1) if chain_id != genesis.chain_id: - validators = self.planetmint.get_validators() + validators = self.planetmint_node.get_validators() self.log_abci_migration_error(chain_id, validators) sys.exit(1) # set migration values for app hash and height - block = self.planetmint.get_latest_block() + block = self.planetmint_node.get_latest_block() app_hash = '' if block is None else block['app_hash'] height = 0 if block is None else block['height'] + 1 - known_validators = self.planetmint.get_validators() + known_validators = self.planetmint_node.get_validators() validator_set = [vutils.decode_validator(v) for v in genesis.validators] @@ -124,10 +124,10 @@ class App(BaseApplication): sys.exit(1) block = Block(app_hash=app_hash, height=height, transactions=[]) - self.planetmint.store_block(block._asdict()) - self.planetmint.store_validator_set(height + 1, validator_set) + self.planetmint_node.store_block(block._asdict()) + self.planetmint_node.store_validator_set(height + 1, validator_set) abci_chain_height = 0 if known_chain is None else known_chain['height'] - self.planetmint.store_abci_chain(abci_chain_height, + self.planetmint_node.store_abci_chain(abci_chain_height, genesis.chain_id, True) self.chain = {'height': abci_chain_height, 'is_synced': True, 'chain_id': genesis.chain_id} @@ -147,7 +147,7 @@ class App(BaseApplication): #logger.info(f"Tendermint version: {request.version}") r = ResponseInfo() - block = self.planetmint.get_latest_block() + block = self.planetmint_node.get_latest_block() if block: chain_shift = 0 if self.chain is None else self.chain['height'] r.last_block_height = block['height'] - chain_shift @@ -169,7 +169,7 @@ class App(BaseApplication): logger.debug('check_tx: %s', raw_transaction) transaction = decode_transaction(raw_transaction) - if self.planetmint.is_valid_transaction(transaction): + if self.planetmint_node.is_valid_transaction(transaction): logger.debug('check_tx: VALID') return ResponseCheckTx(code=CodeTypeOk) else: @@ -203,7 +203,7 @@ class App(BaseApplication): self.abort_if_abci_chain_is_not_synced() logger.debug('deliver_tx: %s', raw_transaction) - transaction = self.planetmint.is_valid_transaction( + transaction = self.planetmint_node.is_valid_transaction( decode_transaction(raw_transaction), self.block_transactions) if not transaction: @@ -235,10 +235,10 @@ class App(BaseApplication): logger.debug(f'Updating pre-commit state: {self.new_height}') pre_commit_state = dict(height=self.new_height, transactions=self.block_txn_ids) - self.planetmint.store_pre_commit_state(pre_commit_state) + self.planetmint_node.store_pre_commit_state(pre_commit_state) block_txn_hash = calculate_hash(self.block_txn_ids) - block = self.planetmint.get_latest_block() + block = self.planetmint_node.get_latest_block() if self.block_txn_ids: self.block_txn_hash = calculate_hash([block['app_hash'], block_txn_hash]) @@ -260,14 +260,14 @@ class App(BaseApplication): # register a new block only when new transactions are received if self.block_txn_ids: - self.planetmint.store_bulk_transactions(self.block_transactions) + self.planetmint_node.store_bulk_transactions(self.block_transactions) block = Block(app_hash=self.block_txn_hash, height=self.new_height, transactions=self.block_txn_ids) # NOTE: storing the block should be the last operation during commit # this effects crash recovery. Refer BEP#8 for details - self.planetmint.store_block(block._asdict()) + self.planetmint_node.store_block(block._asdict()) logger.debug('Commit-ing new block with hash: apphash=%s ,' 'height=%s, txn ids=%s', data, self.new_height, diff --git a/planetmint/parallel_validation.py b/planetmint/parallel_validation.py index 126fabc..040a758 100644 --- a/planetmint/parallel_validation.py +++ b/planetmint/parallel_validation.py @@ -127,7 +127,7 @@ class ValidationWorker: except KeyError: asset_id = dict_transaction['id'] - transaction = self.planetmint.is_valid_transaction( + transaction = self.planetmint_node.is_valid_transaction( dict_transaction, self.validated_transactions[asset_id]) diff --git a/planetmint/upsert_validator/validator_utils.py b/planetmint/upsert_validator/validator_utils.py index b368676..1485920 100644 --- a/planetmint/upsert_validator/validator_utils.py +++ b/planetmint/upsert_validator/validator_utils.py @@ -5,6 +5,7 @@ import enum import planetmint from tendermint.abci import types_pb2 as types_v0_34_11 +from tendermint.crypto import keys_pb2 from planetmint.common.exceptions import InvalidPublicKey, BigchainDBError class TmVersion(enum.Enum): @@ -21,9 +22,9 @@ def encode_validator(v): 'check Planetmint configuration file') validator_update_t, pubkey_t = { - TmVersion.v0_34_11: (types_v0_34_11.ValidatorUpdate, types_v0_34_11.PubKey) + TmVersion.v0_34_11: (types_v0_34_11.ValidatorUpdate, keys_pb2.PublicKey) }[version] - pub_key = pubkey_t(type='ed25519', data=bytes.fromhex(ed25519_public_key)) + pub_key = pubkey_t(ed25519=bytes.fromhex(ed25519_public_key)) return validator_update_t(pub_key=pub_key, power=v['power']) diff --git a/tests/tendermint/conftest.py b/tests/tendermint/conftest.py index 536181a..e3f3ffd 100644 --- a/tests/tendermint/conftest.py +++ b/tests/tendermint/conftest.py @@ -7,7 +7,7 @@ import pytest import codecs from tendermint.abci import types_pb2 as types - +from tendermint.crypto import keys_pb2 @pytest.fixture def validator_pub_key(): @@ -19,5 +19,5 @@ def init_chain_request(): pk = codecs.decode(b'VAgFZtYw8bNR5TMZHFOBDWk9cAmEu3/c6JgRBmddbbI=', 'base64') val_a = types.ValidatorUpdate(power=10, - pub_key=types.PubKey(type='ed25519', data=pk)) + pub_key=keys_pb2.PublicKey(ed25519=pk)) return types.RequestInitChain(validators=[val_a]) diff --git a/tests/test_core.py b/tests/test_core.py index f857d5d..4cfa779 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -1,118 +1,545 @@ -# Copyright © 2020 Interplanetary Database Association e.V., +# Copyright � 2020 Interplanetary Database Association e.V., # Planetmint and IPDB software contributors. # SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) # Code is Apache-2.0 and docs are CC-BY-4.0 +import json import pytest +import random + +from tendermint.abci import types_pb2 as types +from tendermint.crypto import keys_pb2 + +from planetmint import App +from planetmint.backend.localmongodb import query +from planetmint.common.crypto import generate_key_pair +from planetmint.core import (OkCode, + CodeTypeError, + rollback) +from planetmint.elections.election import Election +from planetmint.lib import Block +from planetmint.migrations.chain_migration_election import ChainMigrationElection +from planetmint.upsert_validator.validator_election import ValidatorElection +from planetmint.upsert_validator.validator_utils import new_validator_set +from planetmint.tendermint_utils import public_key_to_base64 +from planetmint.version import __tm_supported_versions__ + +from tests.utils import generate_election, generate_validators -@pytest.fixture -def config(request, monkeypatch): - backend = request.config.getoption('--database-backend') - if backend == 'mongodb-ssl': - backend = 'mongodb' +pytestmark = pytest.mark.bdb - config = { - 'database': { - 'backend': backend, - 'host': 'host', - 'port': 28015, - 'name': 'bigchain', - 'replicaset': 'bigchain-rs', - 'connection_timeout': 5000, - 'max_tries': 3 - }, - 'tendermint': { - 'host': 'localhost', - 'port': 26657, - }, - 'CONFIGURED': True, + +def encode_tx_to_bytes(transaction): + return json.dumps(transaction.to_dict()).encode('utf8') + + +def generate_address(): + return ''.join(random.choices('1,2,3,4,5,6,7,8,9,A,B,C,D,E,F'.split(','), + k=40)).encode() + + +def generate_validator(): + pk, _ = generate_key_pair() + pub_key = keys_pb2.PublicKey(ed25519=pk.encode()) + val = types.ValidatorUpdate(power=10, pub_key=pub_key) + return val + + +def generate_init_chain_request(chain_id, vals=None): + vals = vals if vals is not None else [generate_validator()] + return types.RequestInitChain(validators=vals, chain_id=chain_id) + + +def test_init_chain_successfully_registers_chain(a, b): + request = generate_init_chain_request('chain-XYZ') + res = App(a, b).init_chain(request) + assert res == types.ResponseInitChain() + chain = query.get_latest_abci_chain(b.connection) + assert chain == {'height': 0, 'chain_id': 'chain-XYZ', 'is_synced': True} + assert query.get_latest_block(b.connection) == { + 'height': 0, + 'app_hash': '', + 'transactions': [], } - monkeypatch.setattr('planetmint.config', config) - return config +def test_init_chain_ignores_invalid_init_chain_requests(a, b): + validators = [generate_validator()] + request = generate_init_chain_request('chain-XYZ', validators) + res = App(a, b).init_chain(request) + assert res == types.ResponseInitChain() + + validator_set = query.get_validator_set(b.connection) + + invalid_requests = [ + request, # the same request again + # different validator set + generate_init_chain_request('chain-XYZ'), + # different chain ID + generate_init_chain_request('chain-ABC', validators), + ] + for r in invalid_requests: + with pytest.raises(SystemExit): + App(a, b).init_chain(r) + # assert nothing changed - neither validator set, nor chain ID + new_validator_set = query.get_validator_set(b.connection) + assert new_validator_set == validator_set + new_chain_id = query.get_latest_abci_chain(b.connection)['chain_id'] + assert new_chain_id == 'chain-XYZ' + assert query.get_latest_block(b.connection) == { + 'height': 0, + 'app_hash': '', + 'transactions': [], + } -def test_bigchain_class_default_initialization(config): - from planetmint import Planetmint - from planetmint.validation import BaseValidationRules - from planetmint.backend.connection import Connection - planet = Planetmint() - assert isinstance(planet.connection, Connection) - assert planet.connection.host == config['database']['host'] - assert planet.connection.port == config['database']['port'] - assert planet.connection.dbname == config['database']['name'] - assert planet.validation == BaseValidationRules +def test_init_chain_recognizes_new_chain_after_migration(a, b): + validators = [generate_validator()] + request = generate_init_chain_request('chain-XYZ', validators) + res = App(a, b).init_chain(request) + assert res == types.ResponseInitChain() + validator_set = query.get_validator_set(b.connection)['validators'] -def test_bigchain_class_initialization_with_parameters(): - from planetmint import Planetmint - from planetmint.backend import connect - from planetmint.validation import BaseValidationRules - init_db_kwargs = { - 'backend': 'localmongodb', - 'host': 'this_is_the_db_host', - 'port': 12345, - 'name': 'this_is_the_db_name', + # simulate a migration + query.store_block(b.connection, Block(app_hash='', height=1, + transactions=[])._asdict()) + b.migrate_abci_chain() + + # the same or other mismatching requests are ignored + invalid_requests = [ + request, + generate_init_chain_request('unknown', validators), + generate_init_chain_request('chain-XYZ'), + generate_init_chain_request('chain-XYZ-migrated-at-height-1'), + ] + for r in invalid_requests: + with pytest.raises(SystemExit): + App(a, b).init_chain(r) + assert query.get_latest_abci_chain(b.connection) == { + 'chain_id': 'chain-XYZ-migrated-at-height-1', + 'is_synced': False, + 'height': 2, + } + new_validator_set = query.get_validator_set(b.connection)['validators'] + assert new_validator_set == validator_set + + # a request with the matching chain ID and matching validator set + # completes the migration + request = generate_init_chain_request('chain-XYZ-migrated-at-height-1', + validators) + res = App(a, b).init_chain(request) + assert res == types.ResponseInitChain() + assert query.get_latest_abci_chain(b.connection) == { + 'chain_id': 'chain-XYZ-migrated-at-height-1', + 'is_synced': True, + 'height': 2, } - connection = connect(**init_db_kwargs) - planet = Planetmint(connection=connection) - assert planet.connection == connection - assert planet.connection.host == init_db_kwargs['host'] - assert planet.connection.port == init_db_kwargs['port'] - assert planet.connection.dbname == init_db_kwargs['name'] - assert planet.validation == BaseValidationRules + assert query.get_latest_block(b.connection) == { + 'height': 2, + 'app_hash': '', + 'transactions': [], + } + + # requests with old chain ID and other requests are ignored + invalid_requests = [ + request, + generate_init_chain_request('chain-XYZ', validators), + generate_init_chain_request('chain-XYZ-migrated-at-height-1'), + ] + for r in invalid_requests: + with pytest.raises(SystemExit): + App(a, b).init_chain(r) + assert query.get_latest_abci_chain(b.connection) == { + 'chain_id': 'chain-XYZ-migrated-at-height-1', + 'is_synced': True, + 'height': 2, + } + new_validator_set = query.get_validator_set(b.connection)['validators'] + assert new_validator_set == validator_set + assert query.get_latest_block(b.connection) == { + 'height': 2, + 'app_hash': '', + 'transactions': [], + } -@pytest.mark.bdb -def test_get_spent_issue_1271(b, alice, bob, carol): +def test_info(a, b): + r = types.RequestInfo(version=__tm_supported_versions__[0]) + app = App(a, b) + + res = app.info(r) + assert res.last_block_height == 0 + assert res.last_block_app_hash == b'' + + b.store_block(Block(app_hash='1', height=1, transactions=[])._asdict()) + res = app.info(r) + assert res.last_block_height == 1 + assert res.last_block_app_hash == b'1' + + # simulate a migration and assert the height is shifted + b.store_abci_chain(2, 'chain-XYZ') + app = App(a, b) + b.store_block(Block(app_hash='2', height=2, transactions=[])._asdict()) + res = app.info(r) + assert res.last_block_height == 0 + assert res.last_block_app_hash == b'2' + + b.store_block(Block(app_hash='3', height=3, transactions=[])._asdict()) + res = app.info(r) + assert res.last_block_height == 1 + assert res.last_block_app_hash == b'3' + + # it's always the latest migration that is taken into account + b.store_abci_chain(4, 'chain-XYZ-new') + app = App(a, b) + b.store_block(Block(app_hash='4', height=4, transactions=[])._asdict()) + res = app.info(r) + assert res.last_block_height == 0 + assert res.last_block_app_hash == b'4' + + +def test_check_tx__signed_create_is_ok(a, b): + from planetmint import App + from planetmint.models import Transaction + from planetmint.common.crypto import generate_key_pair + + alice = generate_key_pair() + bob = generate_key_pair() + + tx = Transaction.create([alice.public_key], + [([bob.public_key], 1)])\ + .sign([alice.private_key]) + + app = App(a, b) + result = app.check_tx(encode_tx_to_bytes(tx)) + assert result.code == CodeTypeOk + + +def test_check_tx__unsigned_create_is_error(a, b): + from planetmint import App + from planetmint.models import Transaction + from planetmint.common.crypto import generate_key_pair + + alice = generate_key_pair() + bob = generate_key_pair() + + tx = Transaction.create([alice.public_key], + [([bob.public_key], 1)]) + + app = App(a, b) + result = app.check_tx(encode_tx_to_bytes(tx)) + assert result.code == CodeTypeError + + +def test_deliver_tx__valid_create_updates_db_and_emits_event(a, b, init_chain_request): + import multiprocessing as mp + from planetmint import App + from planetmint.models import Transaction + from planetmint.common.crypto import generate_key_pair + + alice = generate_key_pair() + bob = generate_key_pair() + events = mp.Queue() + + tx = Transaction.create([alice.public_key], + [([bob.public_key], 1)])\ + .sign([alice.private_key]) + + app = App(a, b, events) + + app.init_chain(init_chain_request) + + begin_block = types.RequestBeginBlock() + app.begin_block(begin_block) + + result = app.deliver_tx(encode_tx_to_bytes(tx)) + assert result.code == CodeTypeOk + + app.end_block(types.RequestEndBlock(height=99)) + app.commit() + assert b.get_transaction(tx.id).id == tx.id + block_event = events.get() + assert block_event.data['transactions'] == [tx] + + # unspent_outputs = b.get_unspent_outputs() + # unspent_output = next(unspent_outputs) + # expected_unspent_output = next(tx.unspent_outputs)._asdict() + # assert unspent_output == expected_unspent_output + # with pytest.raises(StopIteration): + # next(unspent_outputs) + + +def test_deliver_tx__double_spend_fails(a, b, init_chain_request): + from planetmint import App + from planetmint.models import Transaction + from planetmint.common.crypto import generate_key_pair + + alice = generate_key_pair() + bob = generate_key_pair() + + tx = Transaction.create([alice.public_key], + [([bob.public_key], 1)])\ + .sign([alice.private_key]) + + app = App(a, b) + app.init_chain(init_chain_request) + + begin_block = types.RequestBeginBlock() + app.begin_block(begin_block) + + result = app.deliver_tx(encode_tx_to_bytes(tx)) + assert result.code == CodeTypeOk + + app.end_block(types.RequestEndBlock(height=99)) + app.commit() + + assert b.get_transaction(tx.id).id == tx.id + result = app.deliver_tx(encode_tx_to_bytes(tx)) + assert result.code == CodeTypeError + + +def test_deliver_transfer_tx__double_spend_fails(a, b, init_chain_request): + from planetmint import App + from planetmint.models import Transaction + from planetmint.common.crypto import generate_key_pair + + app = App(a, b) + app.init_chain(init_chain_request) + + begin_block = types.RequestBeginBlock() + app.begin_block(begin_block) + + alice = generate_key_pair() + bob = generate_key_pair() + carly = generate_key_pair() + + asset = { + 'msg': 'live long and prosper' + } + + tx = Transaction.create([alice.public_key], + [([alice.public_key], 1)], + asset=asset)\ + .sign([alice.private_key]) + + result = app.deliver_tx(encode_tx_to_bytes(tx)) + assert result.code == CodeTypeOk + + tx_transfer = Transaction.transfer(tx.to_inputs(), + [([bob.public_key], 1)], + asset_id=tx.id)\ + .sign([alice.private_key]) + + result = app.deliver_tx(encode_tx_to_bytes(tx_transfer)) + assert result.code == CodeTypeOk + + double_spend = Transaction.transfer(tx.to_inputs(), + [([carly.public_key], 1)], + asset_id=tx.id)\ + .sign([alice.private_key]) + + result = app.deliver_tx(encode_tx_to_bytes(double_spend)) + assert result.code == CodeTypeError + + +def test_end_block_return_validator_updates(a, b, init_chain_request): + app = App(a, b) + app.init_chain(init_chain_request) + + begin_block = types.RequestBeginBlock() + app.begin_block(begin_block) + + # generate a block containing a concluded validator election + validators = generate_validators([1] * 4) + b.store_validator_set(1, [v['storage'] for v in validators]) + + new_validator = generate_validators([1])[0] + + public_key = validators[0]['public_key'] + private_key = validators[0]['private_key'] + voter_keys = [v['private_key'] for v in validators] + + election, votes = generate_election(b, + ValidatorElection, + public_key, private_key, + new_validator['election'], + voter_keys) + b.store_block(Block(height=1, transactions=[election.id], + app_hash='')._asdict()) + b.store_bulk_transactions([election]) + Election.process_block(b, 1, [election]) + + app.block_transactions = votes + + resp = app.end_block(types.RequestEndBlock(height=2)) + assert resp.validator_updates[0].power == new_validator['election']['power'] + expected = bytes.fromhex(new_validator['election']['public_key']['value']) + assert expected == resp.validator_updates[0].pub_key.data + + +def test_store_pre_commit_state_in_end_block(a, b, alice, init_chain_request): + from planetmint import App + from planetmint.backend import query from planetmint.models import Transaction - tx_1 = Transaction.create( - [carol.public_key], - [([carol.public_key], 8)], - ).sign([carol.private_key]) - assert tx_1.validate(b) - b.store_bulk_transactions([tx_1]) + tx = Transaction.create([alice.public_key], + [([alice.public_key], 1)], + asset={'msg': 'live long and prosper'})\ + .sign([alice.private_key]) - tx_2 = Transaction.transfer( - tx_1.to_inputs(), - [([bob.public_key], 2), - ([alice.public_key], 2), - ([carol.public_key], 4)], - asset_id=tx_1.id, - ).sign([carol.private_key]) - assert tx_2.validate(b) - b.store_bulk_transactions([tx_2]) + app = App(a, b) + app.init_chain(init_chain_request) - tx_3 = Transaction.transfer( - tx_2.to_inputs()[2:3], - [([alice.public_key], 1), - ([carol.public_key], 3)], - asset_id=tx_1.id, - ).sign([carol.private_key]) - assert tx_3.validate(b) - b.store_bulk_transactions([tx_3]) + begin_block = types.RequestBeginBlock() + app.begin_block(begin_block) + app.deliver_tx(encode_tx_to_bytes(tx)) + app.end_block(types.RequestEndBlock(height=99)) - tx_4 = Transaction.transfer( - tx_2.to_inputs()[1:2] + tx_3.to_inputs()[0:1], - [([bob.public_key], 3)], - asset_id=tx_1.id, - ).sign([alice.private_key]) - assert tx_4.validate(b) - b.store_bulk_transactions([tx_4]) + resp = query.get_pre_commit_state(b.connection) + assert resp['height'] == 99 + assert resp['transactions'] == [tx.id] - tx_5 = Transaction.transfer( - tx_2.to_inputs()[0:1], - [([alice.public_key], 2)], - asset_id=tx_1.id, - ).sign([bob.private_key]) - assert tx_5.validate(b) + app.begin_block(begin_block) + app.deliver_tx(encode_tx_to_bytes(tx)) + app.end_block(types.RequestEndBlock(height=100)) + resp = query.get_pre_commit_state(b.connection) + assert resp['height'] == 100 + assert resp['transactions'] == [tx.id] - b.store_bulk_transactions([tx_5]) + # simulate a chain migration and assert the height is shifted + b.store_abci_chain(100, 'new-chain') + app = App(a, b) + app.begin_block(begin_block) + app.deliver_tx(encode_tx_to_bytes(tx)) + app.end_block(types.RequestEndBlock(height=1)) + resp = query.get_pre_commit_state(b.connection) + assert resp['height'] == 101 + assert resp['transactions'] == [tx.id] - assert b.get_spent(tx_2.id, 0) == tx_5 - assert not b.get_spent(tx_5.id, 0) - assert b.get_outputs_filtered(alice.public_key) - assert b.get_outputs_filtered(alice.public_key, spent=False) + +def test_rollback_pre_commit_state_after_crash(b): + validators = generate_validators([1] * 4) + b.store_validator_set(1, [v['storage'] for v in validators]) + b.store_block(Block(height=1, transactions=[], app_hash='')._asdict()) + + public_key = validators[0]['public_key'] + private_key = validators[0]['private_key'] + voter_keys = [v['private_key'] for v in validators] + + migration_election, votes = generate_election(b, + ChainMigrationElection, + public_key, private_key, + {}, + voter_keys) + + total_votes = votes + txs = [migration_election, *votes] + + new_validator = generate_validators([1])[0] + validator_election, votes = generate_election(b, + ValidatorElection, + public_key, private_key, + new_validator['election'], + voter_keys) + + total_votes += votes + txs += [validator_election, *votes] + + b.store_bulk_transactions(txs) + b.store_abci_chain(2, 'new_chain') + b.store_validator_set(2, [v['storage'] for v in validators]) + # TODO change to `4` when upgrading to Tendermint 0.22.4. + b.store_validator_set(3, [new_validator['storage']]) + b.store_election(migration_election.id, 2, is_concluded=False) + b.store_election(validator_election.id, 2, is_concluded=True) + + # no pre-commit state + rollback(b) + + for tx in txs: + assert b.get_transaction(tx.id) + assert b.get_latest_abci_chain() + assert len(b.get_validator_change()['validators']) == 1 + assert b.get_election(migration_election.id) + assert b.get_election(validator_election.id) + + b.store_pre_commit_state({'height': 2, 'transactions': [tx.id for tx in txs]}) + + rollback(b) + + for tx in txs: + assert not b.get_transaction(tx.id) + assert not b.get_latest_abci_chain() + assert len(b.get_validator_change()['validators']) == 4 + assert len(b.get_validator_change(2)['validators']) == 4 + assert not b.get_election(migration_election.id) + assert not b.get_election(validator_election.id) + + +def test_new_validator_set(b): + node1 = {'public_key': {'type': 'ed25519-base64', + 'value': 'FxjS2/8AFYoIUqF6AcePTc87qOT7e4WGgH+sGCpTUDQ='}, + 'voting_power': 10} + node1_new_power = {'public_key': {'value': '1718D2DBFF00158A0852A17A01C78F4DCF3BA8E4FB7B8586807FAC182A535034', + 'type': 'ed25519-base16'}, + 'power': 20} + node2 = {'public_key': {'value': '1888A353B181715CA2554701D06C1665BC42C5D936C55EA9C5DBCBDB8B3F02A3', + 'type': 'ed25519-base16'}, + 'power': 10} + + validators = [node1] + updates = [node1_new_power, node2] + b.store_validator_set(1, validators) + updated_validator_set = new_validator_set(b.get_validators(1), updates) + + updated_validators = [] + for u in updates: + updated_validators.append({'public_key': {'type': 'ed25519-base64', + 'value': public_key_to_base64(u['public_key']['value'])}, + 'voting_power': u['power']}) + + assert updated_validator_set == updated_validators + + +def test_info_aborts_if_chain_is_not_synced(a, b): + b.store_abci_chain(0, 'chain-XYZ', False) + + with pytest.raises(SystemExit): + App(a, b).info(types.RequestInfo()) + + +def test_check_tx_aborts_if_chain_is_not_synced(a, b): + b.store_abci_chain(0, 'chain-XYZ', False) + + with pytest.raises(SystemExit): + App(a, b).check_tx('some bytes') + + +def test_begin_aborts_if_chain_is_not_synced(a, b): + b.store_abci_chain(0, 'chain-XYZ', False) + + with pytest.raises(SystemExit): + App(a, b).info(types.RequestBeginBlock()) + + +def test_deliver_tx_aborts_if_chain_is_not_synced(a, b): + b.store_abci_chain(0, 'chain-XYZ', False) + + with pytest.raises(SystemExit): + App(a, b).deliver_tx('some bytes') + + +def test_end_block_aborts_if_chain_is_not_synced(a, b): + b.store_abci_chain(0, 'chain-XYZ', False) + + with pytest.raises(SystemExit): + App(a, b).info(types.RequestEndBlock()) + + +def test_commit_aborts_if_chain_is_not_synced(a, b): + b.store_abci_chain(0, 'chain-XYZ', False) + + with pytest.raises(SystemExit): + App(a, b).commit() \ No newline at end of file