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 tester(): genesis_overrides = {"gas_limit": 7000000} custom_genesis_params = PyEVMBackend._generate_genesis_params( overrides=genesis_overrides) pyevm_backend = PyEVMBackend(genesis_parameters=custom_genesis_params) t = EthereumTester(backend=pyevm_backend) return t
def tester(): # set absurdly high gas limit so that london basefee never adjusts # (note: 2**63 - 1 is max that evm allows) custom_genesis = PyEVMBackend._generate_genesis_params( overrides={"gas_limit": 10**10}) custom_genesis["base_fee_per_gas"] = 0 backend = PyEVMBackend(genesis_parameters=custom_genesis) return EthereumTester(backend=backend)
def _create_w3_instance(self) -> Web3: genesis_overrides = {'gas_limit': int(max_gas_limit * 1.2)} custom_genesis_params = PyEVMBackend._generate_genesis_params( overrides=genesis_overrides) self.eth_tester = EthereumTester(backend=PyEVMBackend( genesis_parameters=custom_genesis_params)) w3 = Web3(Web3.EthereumTesterProvider(self.eth_tester)) return w3
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) 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["block_number"] == 0 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["block_number"] == 0 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_w3(): genesis_overrides = {"gas_limit": 5500000} custom_genesis_params = PyEVMBackend._generate_genesis_params( overrides=genesis_overrides) pyevm_backend = PyEVMBackend(genesis_parameters=custom_genesis_params) t = EthereumTester(backend=pyevm_backend) w3 = Web3(Web3.EthereumTesterProvider(ethereum_tester=t)) w3.eth.defaultAccount = w3.eth.accounts[0] w3.eth.defaultContractFactory = LinkableContract w3.enable_unstable_package_management_api() return w3
def _get_pyevm_test_backend() -> PyEVMBackend: try: # TODO: Consider packaged support of --dev mode with testerchain from tests.constants import PYEVM_GAS_LIMIT, NUMBER_OF_ETH_TEST_ACCOUNTS except ImportError: raise DevelopmentInstallationRequired(importable_name='tests.constants') # 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) return pyevm_backend
def __init__(self, ipcfile=None, blocking=True, **kwargs): if ipcfile is None: genesis_overrides = {'gas_limit': int(1e15), 'difficulty': 1} custom_genesis_params = PyEVMBackend._generate_genesis_params( overrides=genesis_overrides) pyevm_backend = PyEVMBackend( genesis_parameters=custom_genesis_params) t = EthereumTester(backend=pyevm_backend) self.web3 = Web3(EthereumTesterProvider(t)) else: self.web3 = Web3(Web3.IPCProvider(ipcfile, **kwargs)) self.web3.eth.defaultAccount = self.web3.eth.accounts[0] self.libraries = {} self.contract_interface = None self.blocking = blocking
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 _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 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 init_backend_pyevm(self): custom_genesis_params = PyEVMBackend._generate_genesis_params(overrides=self.genesis_overrides) py_backend = PyEVMBackend(genesis_parameters=custom_genesis_params) self.w3 = Web3(EthereumTesterProvider(EthereumTester(py_backend)))
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': genesis_params = PyEVMBackend._generate_genesis_params( overrides={'gas_limit': NUCYPHER_GAS_LIMIT}) pyevm_backend = PyEVMBackend( genesis_parameters=genesis_params) eth_tester = EthereumTester(backend=pyevm_backend, auto_mine_transactions=True) provider = EthereumTesterProvider( ethereum_tester=eth_tester) elif uri_breakdown.netloc == 'geth': # TODO: Auto gethdev # https://web3py.readthedocs.io/en/stable/providers.html # geth-dev-proof-of-authority # from web3.auto.gethdev import w3 # Hardcoded gethdev IPC provider provider = IPCProvider(ipc_path='/tmp/geth.ipc', timeout=timeout) # w3 = Web3(providers=(provider)) # w3.middleware_stack.inject(geth_poa_middleware, layer=0) 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)) # lazy if self.__providers is constants.NO_BLOCKCHAIN_CONNECTION: self.__providers = list() self.__providers.append(provider)
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 _init_provider_from_type(self, config): """ Initialize a provider using the config """ if not config.get('type'): raise SolidbyteException("Invalid configuration. type must be specified") if config['type'] == 'ipc': return IPCProvider(config.get('file') or config.get('url')) elif config['type'] == 'websocket': return WebsocketProvider(config.get('url')) elif config['type'] == 'http': return HTTPProvider(config.get('url')) elif config['type'] in ETH_TESTER_TYPES: # Get genesis params with our non-default block gas limit params = PyEVMBackend._generate_genesis_params(overrides={ 'gas_limit': TEST_BLOCK_GAS_LIMIT, }) # Init EthereumTester with the py-evm backend tester = EthereumTester(backend=PyEVMBackend( genesis_parameters=params ), auto_mine_transactions=True ) # Init the web3.py provider provider = EthereumTesterProvider(ethereum_tester=tester) """ We need to mess with the provider middleware to set the chain_id/net_version. EthereumTesterProvider currently uses fixtures with default values to provide things like responses to net_version or eth_syncing. Ref: https://github.com/ethereum/web3.py/blob/master/web3/providers/eth_tester/middleware.py#L262-L273 # noqa: E501 """ # These definitions are taken from the ref above and cannot be imported fixture_middleware = construct_fixture_middleware({ # Eth 'eth_protocolVersion': '63', 'eth_hashrate': 0, 'eth_gasPrice': 1, 'eth_syncing': False, 'eth_mining': False, # Maybe not standard, but used 'eth_chainId': str(int(datetime.now().timestamp())), # Net 'net_version': str(int(datetime.now().timestamp())), 'net_listening': False, 'net_peerCount': 0, }) # It's a setter/getter property that returns a tuple. Use a list so we can replace. middlewares = list(provider.middlewares) i = 0 replaced = False # TODO: fixture_middleware may no tlonger be default but let's check anyway. This is # probably a depreciated block, however. for m in middlewares: if m.__name__ == 'fixture_middleware': log.debug('Replacing fixture_middleware with our own.') middlewares[i] = fixture_middleware # Replace with our own replaced = True break i += 1 if not replaced: middlewares.append(fixture_middleware) # Set the new middlewars for the provider provider.middlewares = middlewares return provider else: raise SolidbyteException("Invalid configuration. Unknown type")
def ethereum_tester(): custom_genesis = PyEVMBackend._generate_genesis_params( overrides={"gas_limit": 4500000} ) backend = PyEVMBackend(genesis_parameters=custom_genesis) return EthereumTester(backend=backend)
def tester(): custom_genesis = PyEVMBackend._generate_genesis_params( overrides={"gas_limit": 4500000}) custom_genesis["base_fee_per_gas"] = 0 backend = PyEVMBackend(genesis_parameters=custom_genesis) return EthereumTester(backend=backend)
def tester(): genesis_overrides = {'gas_limit': 10000000} custom_genesis_params = PyEVMBackend._generate_genesis_params( overrides=genesis_overrides) return EthereumTester( PyEVMBackend(genesis_parameters=custom_genesis_params))
def eth_tester(): # Calls private method on PyEVMBackend but apparently this is the proper way to do this genesis = PyEVMBackend._generate_genesis_params( {'gas_limit': 2 * GAS_LIMIT}) return EthereumTester(PyEVMBackend(genesis_parameters=genesis))
def main(args): # logging.WARNING=30 level = logging.WARNING - args.verbose * 10 common_handler = logging.StreamHandler() common_handler.setFormatter( logging.Formatter('<%(levelname)s>: %(message)s')) LOGGER.addHandler(common_handler) LOGGER.setLevel(level) my_account_id, my_private_key = \ decode_keyfile(args.keyfile) if args.keyfile \ else login(args.name, args.pkey) gas_handler = logging.FileHandler( GAS_LOGGING_FILEPATH_FORMAT.format(user=my_account_id)) gas_handler.setFormatter(logging.Formatter('%(asctime)s %(message)s')) GASLOG.addHandler(gas_handler) GASLOG.setLevel(logging.DEBUG if args.gaslog else logging.WARNING) if args.endpoint_uri: provider = HTTPProvider(args.endpoint_uri) else: # GASリミットの上限をデフォルトより大きく設定 provider = EthereumTesterProvider(ethereum_tester=EthereumTester( backend=PyEVMBackend( genesis_parameters=PyEVMBackend._generate_genesis_params( overrides={'gas_limit': 4500000})))) viewer_io = None if args.input or args.output: viewer_io = FileViewerIO(args.input, args.output) controller = Controller(my_account_id, my_private_key, provider, dev=args.dev, vio=viewer_io, hookurl=args.webhook) # webhookを待ち受けるサーバアドレスがあれば起動 if args.server: try: WebhookReceiver().start(args.server) except ValueError as err: LOGGER.error('failed to parse url: %s', err) # MISPのオプションが指定されていれば、MISPのtokenの発行 if args.misp: controller.disseminate_mispdata() signal.signal(signal.SIGINT, controller.exit_handler) if args.command: try: controller.menu(args.command) except EOFError: pass signal.raise_signal(signal.SIGINT) while True: try: controller.menu() except EOFError: continue # keep on going