def __init__(self, generate_keys=0):
self.tester = EthereumTester(PyEVMBackend())
self.web3 = Web3(EthereumTesterProvider(self.tester))
if generate_keys > 0:
generated_keys = [urandom(32) for _ in range(generate_keys)]
self.private_keys = [PrivateKey(key) for key in generated_keys]
self.accounts = [
self.tester.add_account(f'0x{hexlify(key).decode()}')
for key in generated_keys
]
for account in self.accounts:
self.tester.send_transaction({
'from':
self.tester.get_accounts()[0],
'to':
account,
'value':
10**21,
'gas':
21000,
})
else:
self.accounts = self.tester.get_accounts()
self.contract_manager = ContractManager(CONTRACTS_SOURCE_DIRS)
self.name_to_creation_hash = dict()
self.name_to_contract = dict()
def setup_method(self):
py_evm_main.GENESIS_GAS_LIMIT = 10000000
self.web3 = Web3(EthereumTesterProvider(EthereumTester(
PyEVMBackend())))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.zrx_token = ERC20Token(web3=self.web3,
address=deploy_contract(
self.web3, 'ZRXToken'))
self.token_transfer_proxy_address = deploy_contract(
self.web3, 'TokenTransferProxy')
self.exchange = ZrxExchange.deploy(self.web3, self.zrx_token.address,
self.token_transfer_proxy_address)
self.web3.eth.contract(abi=json.loads(
pkg_resources.resource_string(
'pymaker.deployment', f'abi/TokenTransferProxy.abi')))(
address=self.token_transfer_proxy_address.address
).functions.addAuthorizedAddress(
self.exchange.address.address).transact()
self.zrx_api = ZrxApi(self.exchange)
self.dgx = DSToken.deploy(self.web3, 'DGX')
self.dai = DSToken.deploy(self.web3, 'DAI')
self.pair = Pair(self.dgx.address, 9, self.dai.address, 18)
def __init__(self, generate_keys=0):
self.tester = EthereumTester(PyEVMBackend())
self.web3 = Web3(EthereumTesterProvider(self.tester))
if generate_keys > 0:
self.private_keys = [urandom(32) for _ in range(generate_keys)]
self.accounts = [
self.tester.add_account(encode_hex(key))
for key in self.private_keys
]
for account in self.accounts:
self.tester.send_transaction({
"from":
self.tester.get_accounts()[0],
"to":
account,
"value":
10**21,
"gas":
21000,
})
else:
self.accounts = self.tester.get_accounts()
self.contract_manager = ContractManager(CONTRACTS_SOURCE_DIRS)
self.name_to_creation_hash = dict()
self.name_to_contract = dict()
def _get_tester_pyevm(provider_uri):
# https://web3py.readthedocs.io/en/latest/providers.html#httpprovider
from nucypher.utilities.sandbox.constants import PYEVM_GAS_LIMIT, NUMBER_OF_ETH_TEST_ACCOUNTS
# Initialize
genesis_params = PyEVMBackend._generate_genesis_params(
overrides={'gas_limit': PYEVM_GAS_LIMIT})
pyevm_backend = PyEVMBackend(genesis_parameters=genesis_params)
pyevm_backend.reset_to_genesis(genesis_params=genesis_params,
num_accounts=NUMBER_OF_ETH_TEST_ACCOUNTS)
# Test provider entry-point
eth_tester = EthereumTester(backend=pyevm_backend,
auto_mine_transactions=True)
provider = EthereumTesterProvider(ethereum_tester=eth_tester)
return provider
def get_contract_module(no_optimize):
"""
This fixture is used for Hypothesis tests to ensure that
the same contract is called over multiple runs of the test.
"""
custom_genesis = PyEVMBackend._generate_genesis_params(
overrides={"gas_limit": 4500000})
custom_genesis["base_fee_per_gas"] = 0
backend = PyEVMBackend(genesis_parameters=custom_genesis)
tester = EthereumTester(backend=backend)
w3 = Web3(EthereumTesterProvider(tester))
w3.eth.set_gas_price_strategy(zero_gas_price_strategy)
def get_contract_module(source_code, *args, **kwargs):
return _get_contract(w3, source_code, no_optimize, *args, **kwargs)
return get_contract_module
def add_provider(self,
provider: Union[IPCProvider, WebsocketProvider, HTTPProvider] = None,
provider_uri: str = None,
timeout: int = None) -> None:
if not provider_uri and not provider:
raise self.NoProvider("No URI or provider instances supplied.")
if provider_uri and not provider:
uri_breakdown = urlparse(provider_uri)
# PyEVM
if uri_breakdown.scheme == 'tester':
if uri_breakdown.netloc == 'pyevm':
from nucypher.utilities.sandbox.constants import PYEVM_GAS_LIMIT
genesis_params = PyEVMBackend._generate_genesis_params(overrides={'gas_limit': PYEVM_GAS_LIMIT})
pyevm_backend = PyEVMBackend(genesis_parameters=genesis_params)
pyevm_backend.reset_to_genesis(genesis_params=genesis_params,
num_accounts=NUMBER_OF_ETH_TEST_ACCOUNTS)
eth_tester = EthereumTester(backend=pyevm_backend, auto_mine_transactions=True)
provider = EthereumTesterProvider(ethereum_tester=eth_tester)
elif uri_breakdown.netloc == 'geth':
# Hardcoded gethdev IPC provider
provider = IPCProvider(ipc_path='/tmp/geth.ipc', timeout=timeout)
else:
raise ValueError("{} is an invalid or unsupported blockchain provider URI".format(provider_uri))
# IPC
elif uri_breakdown.scheme == 'ipc':
provider = IPCProvider(ipc_path=uri_breakdown.path, timeout=timeout)
# Websocket
elif uri_breakdown.scheme == 'ws':
provider = WebsocketProvider(endpoint_uri=provider_uri)
# HTTP
elif uri_breakdown.scheme in ('http', 'https'):
provider = HTTPProvider(endpoint_uri=provider_uri)
else:
raise self.InterfaceError("'{}' is not a blockchain provider protocol".format(uri_breakdown.scheme))
self.__provider = provider
def test_generate_custom_genesis_parameters(self):
# Establish parameter overrides, for example a custom genesis gas limit
param_overrides = {"gas_limit": 4750000}
# Test the underlying default parameter merging functionality
genesis_params = get_default_genesis_params(overrides=param_overrides)
assert genesis_params["gas_limit"] == param_overrides["gas_limit"]
# Use the the staticmethod to generate custom genesis parameters
genesis_params = PyEVMBackend.generate_genesis_params(param_overrides)
assert genesis_params["gas_limit"] == param_overrides["gas_limit"]
# Only existing default genesis parameter keys can be overridden
invalid_overrides = {"gato": "con botas"}
with pytest.raises(ValueError):
_invalid_genesis_params = PyEVMBackend.generate_genesis_params(
overrides=invalid_overrides)
def setUp(self):
backend = PyEVMBackend()
tester = EthereumTester(backend)
self.provider = EthereumTesterProvider(tester)
private_key = backend.account_keys[0].to_hex()
self.w3 = Web3(self.provider)
self.account = self.w3.eth.account.privateKeyToAccount(private_key)
d = Deployer(self.provider, self.account)
self.addresses = d.deploy(network_addr=NETWORK_ADDR)
def contract():
eth_tester = EthereumTester(
backend=PyEVMBackend(),
auto_mine_transactions=False,
)
provider = EthereumTesterProvider(eth_tester)
w3 = Web3(provider)
tx_hash = w3.eth.sendTransaction(assoc(default_tx_detail, 'data', bytecode))
mine(w3, 1)
receipt = w3.eth.getTransactionReceipt(tx_hash)
contract_address = receipt['contractAddress']
return w3.eth.contract(contract_address, abi=abi, bytecode=bytecode)
def test_override_genesis_parameters(self):
# Establish a custom gas limit
param_overrides = {"gas_limit": 4750000}
block_one_gas_limit = param_overrides['gas_limit']
# Initialize PyEVM backend with custom genesis parameters
genesis_params = PyEVMBackend._generate_genesis_params(
overrides=param_overrides)
pyevm_backend = PyEVMBackend(genesis_parameters=genesis_params)
genesis_block = pyevm_backend.get_block_by_number(0)
assert genesis_block["gas_limit"] == param_overrides["gas_limit"]
genesis_block = pyevm_backend.get_block_by_number(1)
assert genesis_block["gas_limit"] == block_one_gas_limit
# Integrate with EthereumTester
tester = EthereumTester(backend=pyevm_backend)
genesis_block = tester.get_block_by_number(0)
assert genesis_block["gas_limit"] == param_overrides["gas_limit"]
genesis_block = tester.get_block_by_number(1)
assert genesis_block["gas_limit"] == block_one_gas_limit
def test_override_genesis_state(self):
state_overrides = {"balance": to_wei(900000, "ether")}
test_accounts = 3
# Initialize PyEVM backend with custom genesis state
genesis_state = PyEVMBackend._generate_genesis_state(
overrides=state_overrides, num_accounts=test_accounts)
# Test the correct number of accounts are created with the specified balance override
pyevm_backend = PyEVMBackend(genesis_state=genesis_state)
assert len(pyevm_backend.account_keys) == test_accounts
for private_key in pyevm_backend.account_keys:
account = private_key.public_key.to_canonical_address()
balance = pyevm_backend.get_balance(account=account)
assert balance == state_overrides["balance"]
# Test integration with EthereumTester
tester = EthereumTester(backend=pyevm_backend)
for private_key in pyevm_backend.account_keys:
account = private_key.public_key.to_checksum_address()
balance = tester.get_balance(account=account)
assert balance == state_overrides["balance"]
def add_provider(self,
provider: Union[IPCProvider, WebsocketProvider, HTTPProvider] = None,
provider_uri: str = None,
timeout: int = None) -> None:
if not provider_uri and not provider:
raise self.InterfaceError("No URI or provider instances supplied.")
if provider_uri and not provider:
uri_breakdown = urlparse(provider_uri)
# PyEVM
if uri_breakdown.scheme == 'pyevm':
if uri_breakdown.netloc == 'tester':
NUCYPHER_GAS_LIMIT = 5000000 # TODO: Move to constants
genesis_parameter_overrides = {'gas_limit': NUCYPHER_GAS_LIMIT}
# TODO: Update to newest eth-tester after #123 is merged
pyevm_backend = PyEVMBackend.from_genesis_overrides(parameter_overrides=genesis_parameter_overrides)
eth_tester = EthereumTester(backend=pyevm_backend, auto_mine_transactions=True)
provider = EthereumTesterProvider(ethereum_tester=eth_tester)
elif uri_breakdown.netloc == 'trinity':
raise NotImplemented
else:
raise self.InterfaceError("{} is an ambiguous or unsupported blockchain provider URI".format(provider_uri))
# IPC
elif uri_breakdown.scheme == 'ipc':
provider = IPCProvider(ipc_path=uri_breakdown.path, timeout=timeout)
# Websocket
elif uri_breakdown.scheme == 'ws':
provider = WebsocketProvider(endpoint_uri=provider_uri)
# HTTP
elif uri_breakdown.scheme in ('http', 'https'):
provider = HTTPProvider(endpoint_uri=provider_uri)
else:
raise self.InterfaceError("'{}' is not a blockchain provider protocol".format(uri_breakdown.scheme))
# lazy
if self.__providers is constants.NO_BLOCKCHAIN_CONNECTION:
self.__providers = list()
self.__providers.append(provider)
def test_berlin_configuration():
if not is_supported_pyevm_version_available():
pytest.skip("PyEVM is not available")
mnemonic = "test test test test test test test test test test test junk"
vm_configuration = ((0, BerlinVM), )
backend = PyEVMBackend.from_mnemonic(mnemonic,
vm_configuration=vm_configuration)
# Berlin blocks shouldn't have base_fee_per_gas,
# since London was the fork that introduced base_fee_per_gas
with pytest.raises(KeyError):
backend.get_block_by_number(0)['base_fee_per_gas']
EthereumTester(backend=backend)
def __init__(self, request):
self.eth_tester = EthereumTester(backend=PyEVMBackend(genesis_parameters=custom_genesis_params, genesis_state=custom_genesis_state))
self.testerProvider = EthereumTesterProvider(ethereum_tester=self.eth_tester)
self.w3 = Web3(self.testerProvider)
self.eth_tester.backend.chain.gas_estimator = dumb_gas_search
self.privateKeys = self.eth_tester.backend.account_keys
self.accounts = self.eth_tester.get_accounts()
self.contracts = {}
self.relativeContractsPath = '../source/contracts'
self.relativeTestContractsPath = 'solidity_test_helpers'
# self.relativeTestContractsPath = 'mock_templates/contracts'
self.coverageMode = request.config.option.cover
self.subFork = request.config.option.subFork
self.logListener = None
if self.coverageMode:
self.logListener = self.writeLogToFile
self.relativeContractsPath = '../coverageEnv/contracts'
self.relativeTestContractsPath = '../coverageEnv/solidity_test_helpers'
def __init__(self, generate_keys=0):
self.tester = EthereumTester(PyEVMBackend())
self.web3 = Web3(EthereumTesterProvider(self.tester))
if generate_keys > 0:
self.private_keys = [urandom(32) for _ in range(generate_keys)]
self.accounts = [self.tester.add_account(encode_hex(key)) for key in self.private_keys]
for account in self.accounts:
self.tester.send_transaction(
{
"from": self.tester.get_accounts()[0],
"to": account,
"value": 10 ** 21,
"gas": 21000,
}
)
else:
self.accounts = self.tester.get_accounts()
self.contract_manager = ContractManager(
contracts_precompiled_path(RAIDEN_CONTRACT_VERSION)
)
self.name_to_creation_hash: Dict[str, bytes] = dict()
self.name_to_contract: Dict[str, str] = dict()
def test_berlin_configuration():
if not is_supported_pyevm_version_available():
pytest.skip("PyEVM is not available")
mnemonic = "test test test test test test test test test test test junk"
vm_configuration = ((0, BerlinVM), )
backend = PyEVMBackend.from_mnemonic(mnemonic,
vm_configuration=vm_configuration)
# Berlin blocks shouldn't have base_fee_per_gas,
# since London was the fork that introduced base_fee_per_gas
with pytest.raises(KeyError):
backend.get_block_by_number(0)['base_fee_per_gas']
tester = EthereumTester(backend=backend)
# Test that outbound block validation doesn't break by getting a block.
berlin_block = tester.get_block_by_number(0)
# Test that outbound block normalization removes `base_fee_per_gas`.
with pytest.raises(KeyError):
berlin_block['base_fee_per_gas']
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
def test_custom_virtual_machines():
if not is_pyevm_available():
pytest.skip("PyEVM is not available")
backend = PyEVMBackend(vm_configuration=(
(0, FrontierVM),
(3, BerlinVM),
))
# This should be a FrontierVM block
VM_at_2 = backend.chain.get_vm_class_for_block_number(2)
# This should be a BerlinVM block
VM_at_3 = backend.chain.get_vm_class_for_block_number(3)
assert issubclass(VM_at_2, FrontierVM)
assert not issubclass(VM_at_2, BerlinVM)
assert issubclass(VM_at_3, BerlinVM)
# Right now, just test that EthereumTester doesn't crash
# Maybe some more sophisticated test to make sure the VMs are set correctly?
# We should to make sure the VM config translates all the way to the main
# tester, maybe with a custom VM that hard-codes some block value? that can
# be found with tester.get_block_by_number()?
EthereumTester(backend=backend)
def tester():
return EthereumTester(backend=PyEVMBackend())
def ethereum_tester(patch_genesis_gas_limit): # pylint: disable=W0613
"""Returns an instance of an Ethereum tester"""
return EthereumTester(PyEVMBackend())
from eth.vm.forks.homestead.computation import (
HomesteadComputation,
)
from eth.vm.forks.spurious_dragon.opcodes import SPURIOUS_DRAGON_OPCODES
from hexbytes.main import HexBytes
import rlp
import web3
genesis_overrides = {
'gas_limit': 800000000
}
custom_genesis_params = PyEVMBackend._generate_genesis_params(overrides=genesis_overrides)
custom_genesis_state = PyEVMBackend._generate_genesis_state(num_accounts=9)
# Hacks to reduce test time
def new_is_valid_opcode(self, position: int) -> bool:
return True
def new_default_middlewares(self, web3):
return [
(request_parameter_normalizer, 'request_param_normalizer'),
(gas_price_strategy_middleware, 'gas_price_strategy'),
(name_to_address_middleware(web3), 'name_to_address'),
(attrdict_middleware, 'attrdict'),
(pythonic_middleware, 'pythonic'),
(normalize_errors_middleware, 'normalize_errors'),
(validation_middleware, 'validation'),
def ethereum_tester(patch_genesis_gas_limit):
"""Returns an instance of an Ethereum tester"""
return EthereumTester(PyEVMBackend())
def purity_checker_address():
tmp_tester = EthereumTester(PyEVMBackend())
tmp_w3 = w3(tmp_tester)
address = deploy_purity_checker(tmp_w3)()
return address
def msg_hasher_address():
tmp_tester = EthereumTester(PyEVMBackend())
tmp_w3 = w3(tmp_tester)
address = deploy_msg_hasher(tmp_w3)()
return address
def vyper_rlp_decoder_address():
tmp_tester = EthereumTester(PyEVMBackend())
tmp_w3 = w3(tmp_tester)
address = deploy_rlp_decoder(tmp_w3)()
return address
def tester():
genesis_params = PyEVMBackend._generate_genesis_params(overrides={'gas_limit': 7 * 10 ** 6})
pyevm_backend = PyEVMBackend(genesis_parameters=genesis_params)
pyevm_backend.reset_to_genesis(genesis_params=genesis_params, num_accounts=10)
return EthereumTester(backend=pyevm_backend, auto_mine_transactions=True)
def ethereum_tester():
"""Returns an instance of an Ethereum tester"""
return EthereumTester(PyEVMBackend())
def base_tester():
return EthereumTester(PyEVMBackend())
def tester():
return EthereumTester(backend=PyEVMBackend(), auto_mine_transactions=True)
def ethereum_tester():
custom_genesis = PyEVMBackend._generate_genesis_params(
overrides={"gas_limit": 4500000}
)
backend = PyEVMBackend(genesis_parameters=custom_genesis)
return EthereumTester(backend=backend)
