Mirroristas/planetmint
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint.git synced 2025-06-06 06:06:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Resolved PubKey issue

Browse Source
This commit is contained in:
ArpitShukla007 2022-02-02 08:03:42 +00:00
parent 89bbabf818
commit 959d2e98f0
5 changed files with 544 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
planetmint/core.py
View File

@ -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,

2
planetmint/parallel_validation.py
View File

@ -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])

5
planetmint/upsert_validator/validator_utils.py
View File

@ -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'])

4
tests/tendermint/conftest.py
View File

@ -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])

611
tests/test_core.py
View File

@ -1,118 +1,545 @@
# Copyright © 2020 Interplanetary Database Association e.V.,
# Copyright <EFBFBD> 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()