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)