def test_generate_custom_genesis_state(self):
state_overrides = {"balance": to_wei(900000, "ether")}
invalid_overrides = {"gato": "con botas"}
# Test creating a specific number of accounts
account_keys = get_default_account_keys(quantity=2)
assert len(account_keys) == 2
account_keys = get_default_account_keys(quantity=10)
assert len(account_keys) == 10
# Test the underlying state merging functionality
genesis_state = generate_genesis_state_for_keys(
account_keys=account_keys, overrides=state_overrides)
assert len(genesis_state) == len(account_keys) == 10
for _public_address, account_state in genesis_state.items():
assert account_state["balance"] == state_overrides["balance"]
assert account_state["code"] == b""
# Only existing default genesis state keys can be overridden
with pytest.raises(ValueError):
_invalid_genesis_state = generate_genesis_state_for_keys(
account_keys=account_keys, overrides=invalid_overrides)
# Use staticmethod state overriding
genesis_state = PyEVMBackend._generate_genesis_state(
overrides=state_overrides, num_accounts=3)
assert len(genesis_state) == 3
for _public_address, account_state in genesis_state.items():
assert account_state["balance"] == state_overrides["balance"]
assert account_state["code"] == b""
# Only existing default genesis state keys can be overridden
with pytest.raises(ValueError):
_invalid_genesis_state = PyEVMBackend._generate_genesis_state(
overrides=invalid_overrides)
def vmc():
eth_tester = EthereumTester(
backend=PyEVMBackend(),
auto_mine_transactions=False,
)
provider = EthereumTesterProvider(eth_tester)
w3 = Web3(provider)
if hasattr(w3.eth, "enable_unaudited_features"):
w3.eth.enable_unaudited_features()
# setup vmc's web3.eth.contract instance
vmc_tx = create_vmc_tx(
ByzantiumTransaction,
get_sharding_config()['GAS_PRICE'],
)
vmc_addr = get_contract_address_from_contract_tx(vmc_tx)
vmc_json = get_vmc_json()
vmc_abi = vmc_json['abi']
vmc_bytecode = vmc_json['bytecode']
VMCClass = VMC.factory(w3, abi=vmc_abi, bytecode=vmc_bytecode)
test_keys = get_default_account_keys()
vmc_handler = VMCClass(
to_checksum_address(vmc_addr),
default_privkey=test_keys[0],
)
vmc_handler.vmc_tx_sender_address = vmc_tx.sender
return vmc_handler
def smc_handler():
eth_tester = EthereumTester(
backend=PyEVMBackend(),
auto_mine_transactions=False,
)
provider = EthereumTesterProvider(eth_tester)
w3 = Web3(provider)
if hasattr(w3.eth, "enable_unaudited_features"):
w3.eth.enable_unaudited_features()
default_privkey = get_default_account_keys()[0]
# deploy smc contract
smc_addr = deploy_smc_contract(
w3,
get_sharding_config()['GAS_PRICE'],
default_privkey,
)
assert get_code(w3, smc_addr) != b''
# setup smc_handler's web3.eth.contract instance
smc_json = get_smc_json()
smc_abi = smc_json['abi']
smc_bytecode = smc_json['bytecode']
SMCHandlerClass = SMCHandler.factory(w3,
abi=smc_abi,
bytecode=smc_bytecode)
smc_handler = SMCHandlerClass(
to_checksum_address(smc_addr),
default_privkey=default_privkey,
)
return smc_handler
def reset_to_genesis(self, overrides=None):
from evm.chains.tester import MainnetTesterChain
from evm.db import get_db_backend
base_db = get_db_backend()
genesis_params = get_default_genesis_params()
# Genesis params overrides
if overrides is not None:
genesis_params.update(overrides)
account_keys = get_default_account_keys()
genesis_state = generate_genesis_state(account_keys)
chain = MainnetTesterChain.from_genesis(base_db, genesis_params, genesis_state)
self.account_keys, self.chain = account_keys, chain
def _setup_tester_chain(genesis_params, genesis_state, num_accounts):
class DebugNoProofVM(DebugVM):
"""Byzantium VM rules, without validating any miner proof of work"""
@classmethod
def validate_seal(self, header):
pass
class MainnetTesterNoProofChain(MiningChain):
vm_configuration = ((0, DebugNoProofVM), )
genesis_params = get_default_genesis_params()
account_keys = get_default_account_keys(quantity=num_accounts)
genesis_state = generate_genesis_state_for_keys(account_keys)
base_db = get_db_backend()
chain = MainnetTesterNoProofChain.from_genesis(base_db, genesis_params,
genesis_state)
return account_keys, chain
def smc_handler(smc_testing_config):
eth_tester = EthereumTester(
backend=PyEVMBackend(),
auto_mine_transactions=False,
)
provider = EthereumTesterProvider(eth_tester)
w3 = Web3(provider)
if hasattr(w3.eth, "enable_unaudited_features"):
w3.eth.enable_unaudited_features()
private_key = get_default_account_keys()[0]
# deploy smc contract
SMCHandler = w3.eth.contract(ContractFactoryClass=SMCHandlerFactory)
constructor_kwargs = {
"_SHARD_COUNT": smc_testing_config["SHARD_COUNT"],
"_PERIOD_LENGTH": smc_testing_config["PERIOD_LENGTH"],
"_LOOKAHEAD_LENGTH": smc_testing_config["LOOKAHEAD_PERIODS"],
"_COMMITTEE_SIZE": smc_testing_config["COMMITTEE_SIZE"],
"_QUORUM_SIZE": smc_testing_config["QUORUM_SIZE"],
"_NOTARY_DEPOSIT": smc_testing_config["NOTARY_DEPOSIT"],
"_NOTARY_LOCKUP_LENGTH": smc_testing_config["NOTARY_LOCKUP_LENGTH"],
}
eth_tester.enable_auto_mine_transactions()
deployment_tx_hash = SMCHandler.constructor(
**constructor_kwargs).transact()
deployment_receipt = w3.eth.waitForTransactionReceipt(deployment_tx_hash,
timeout=0)
eth_tester.disable_auto_mine_transactions()
assert get_code(w3, deployment_receipt.contractAddress) != b''
smc_handler = SMCHandler(
address=deployment_receipt.contractAddress,
private_key=private_key,
config=smc_testing_config,
)
return smc_handler
from evm.vm.forks.sharding.vmc_handler import (
NextLogUnavailable,
ShardTracker,
parse_collation_added_log,
)
from evm.vm.forks.sharding.vmc_utils import (
create_vmc_tx, )
from tests.sharding.fixtures import ( # noqa: F401
vmc, )
PASSPHRASE = '123'
GENESIS_COLHDR_HASH = b'\x00' * 32
ZERO_ADDR = b'\x00' * 20
test_keys = get_default_account_keys()
logger = logging.getLogger('evm.chain.sharding.mainchain_handler.VMCHandler')
def get_code(vmc_handler, address):
return vmc_handler.web3.eth.getCode(to_checksum_address(address))
def get_nonce(vmc_handler, address):
return vmc_handler.web3.eth.getTransactionCount(
to_checksum_address(address))
def mine(vmc_handler, num_blocks):
vmc_handler.web3.testing.mine(num_blocks)
def private_key(self):
return get_default_account_keys()[self.index]
import pytest
import vyper
from eth_account import Account
from eth_tester.backends.pyevm.main import get_default_account_keys
from plasma_cash import (
Operator,
RootChain,
Token,
User,
)
DEFAULT_KEYS = get_default_account_keys()
DEFAULT_ACCOUNTS = [
Account.privateKeyToAccount(k).address for k in DEFAULT_KEYS
]
with open('contracts/Token.vy', 'r') as f:
token_interface = vyper.compile_code(
f.read(), output_formats=['abi', 'bytecode', 'bytecode_runtime'])
# Hack until pytest-ethereum includes a way to change the block timestamp
def set_challenge_period(code, new_param):
return code.replace(
"""
CHALLENGE_PERIOD: constant(timedelta) = 604800 # 7 days (7*24*60*60 secs)
""", f"""
CHALLENGE_PERIOD: constant(timedelta) = {new_param} # secs (NOTE monkeypatched!)
""")
