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
