def __init__(self,
backend=None,
validator=None,
normalizer=None,
auto_mine_transactions=True,
fork_blocks=None):
if backend is None:
backend = get_chain_backend()
if validator is None:
validator = get_validator()
if normalizer is None:
normalizer = get_normalizer_backend()
self.backend = backend
self.validator = validator
self.normalizer = normalizer
self.auto_mine_transactions = auto_mine_transactions
if fork_blocks is None:
fork_blocks = get_default_fork_blocks(self.get_supported_forks())
unsupported_forks = set(fork_blocks.keys()).difference(self.get_supported_forks())
if unsupported_forks:
raise UnknownFork(
"The following forks are not supported by the backend you are "
"using: {0}".format(sorted(unsupported_forks))
)
for fork_name, fork_block in fork_blocks.items():
self.set_fork_block(fork_name, fork_block)
self._reset_local_state()
def set_fork_block(self, fork_name, fork_block):
if fork_name in SUPPORTED_FORKS:
if fork_block:
self.fork_blocks[fork_name] = fork_block
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
self.chain.configure_forks()
def get_fork_block(self, fork_name):
if fork_name in SUPPORTED_FORKS:
return self.fork_blocks.get(fork_name, 0)
elif fork_name == FORK_STATE_CLEANUP:
# TODO: get EIP160 rules implemented in py-evm
return self.fork_blocks.get(fork_name, 0)
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
def set_fork_block(self, fork_name, fork_block):
if fork_name in self.get_supported_forks():
if fork_block is not None:
self.fork_config[fork_name] = fork_block
elif fork_block is None:
self.fork_config.pop(fork_name, None)
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
self.configure_forks()
def set_fork_block(self, fork_name, fork_block):
if fork_name == FORK_HOMESTEAD:
self.evm.env.config['HOMESTEAD_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_DAO:
self.evm.env.config['DAO_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_ANTI_DOS:
self.evm.env.config['ANTI_DOS_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_STATE_CLEANUP:
self.evm.env.config['CLEARING_FORK_BLKNUM'] = fork_block
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
def get_fork_block(self, fork_name):
if fork_name == FORK_HOMESTEAD:
return self.evm.chain.env.config['HOMESTEAD_FORK_BLKNUM']
elif fork_name == FORK_DAO:
return self.evm.chain.env.config['DAO_FORK_BLKNUM']
elif fork_name == FORK_ANTI_DOS:
return self.evm.chain.env.config['ANTI_DOS_FORK_BLKNUM']
elif fork_name == FORK_STATE_CLEANUP:
return self.evm.chain.env.config['CLEARING_FORK_BLKNUM']
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
def set_fork_block(self, fork_name, fork_block=0):
if fork_name == FORK_HOMESTEAD:
self.evm.env.config['HOMESTEAD_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_DAO:
self.evm.env.config['DAO_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_SPURIOUS_DRAGON:
self.evm.env.config['ANTI_DOS_FORK_BLKNUM'] = fork_block
self.evm.env.config['SPURIOUS_DRAGON_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_TANGERINE_WHISTLE:
self.evm.env.config['CLEARING_FORK_BLKNUM'] = fork_block
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
self.fork_blocks[fork_name] = fork_block
def set_fork_block(self, fork_name, fork_block):
if fork_name in SUPPORTED_FORKS:
if fork_block:
self.fork_blocks[fork_name] = fork_block
elif fork_name == FORK_STATE_CLEANUP:
warnings.warn(UserWarning(
"Py-EVM does not currently support the SpuriousDragon hard fork."
))
# TODO: get EIP160 rules implemented in py-evm
self.fork_blocks[fork_name] = fork_block
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
self.chain.configure_forks()
def set_fork_block(self, fork_name, fork_block):
if fork_name == FORK_HOMESTEAD:
self.evm.chain.env.config['HOMESTEAD_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_DAO:
# NOTE: REALLY WEIRD HACK to get the dao_fork_blk to accept block 0
if not fork_block:
self.evm.chain.env.config['DAO_FORK_BLKNUM'] = 999999999999999
else:
self.evm.chain.env.config['DAO_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_ANTI_DOS:
self.evm.chain.env.config['ANTI_DOS_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_STATE_CLEANUP:
self.evm.chain.env.config['CLEARING_FORK_BLKNUM'] = fork_block
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
def set_fork_block(self, fork_name, fork_block=0):
if fork_name == FORK_HOMESTEAD:
self.evm.chain.env.config['HOMESTEAD_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_DAO:
# NOTE: REALLY WEIRD HACK to get the dao_fork_blk to accept block 0
if not fork_block:
self.evm.chain.env.config['DAO_FORK_BLKNUM'] = 999999999999999
else:
self.evm.chain.env.config['DAO_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_SPURIOUS_DRAGON:
# pyethereum seems to use both of these.
self.evm.chain.env.config['ANTI_DOS_FORK_BLKNUM'] = fork_block
self.evm.chain.env.config[
'SPURIOUS_DRAGON_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_TANGERINE_WHISTLE:
self.evm.chain.env.config['CLEARING_FORK_BLKNUM'] = fork_block
elif fork_name == FORK_BYZANTIUM:
self.evm.chain.env.config['METROPOLIS_FORK_BLKNUM'] = fork_block
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
self.fork_blocks[fork_name] = fork_block
def get_fork_block(self, fork_name):
if fork_name not in self.get_supported_forks():
raise UnknownFork("Unknown fork: {0}".format(fork_name))
return self.backend.get_fork_block(fork_name)
def get_fork_block(self, fork_name):
if fork_name in self.get_supported_forks():
return self.fork_blocks.get(fork_name)
else:
raise UnknownFork("Unknown fork name: {0}".format(fork_name))
def get_fork_block(self, fork_name):
try:
return self.fork_blocks[fork_name]
except KeyError:
raise UnknownFork("Unknown fork: {0}".format(fork_name))